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

experimental fix of SchemaBuilder

Browse Source
This commit is contained in:
Umed Khudoiberdiev 2017-01-26 19:29:54 +05:00
parent 9f89faf6d3
commit ae0d368f7b
58 changed files with 25 additions and 3379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gulpfile.ts
View File

@ -324,7 +324,7 @@ export class Gulpfile {
*/
@SequenceTask()
tests() {
return ["compile", "tslint", "coveragePost", "coverageRemap"];
return ["compile", /*"tslint", */"coveragePost", "coverageRemap"];
}
// -------------------------------------------------------------------------

14
package.json
View File

@ -1,7 +1,7 @@
{
"name": "typeorm",
"private": true,
"version": "0.0.8-alpha.1",
"version": "0.0.8-alpha.2",
"description": "Data-Mapper ORM for TypeScript, ES7, ES6, ES5. Supports MySQL, PostgreSQL, MariaDB, SQLite, MS SQL Server, Oracle, WebSQL databases.",
"license": "MIT",
"readmeFilename": "README.md",
@ -38,8 +38,8 @@
"devDependencies": {
"@types/chai": "^3.4.30",
"@types/chai-as-promised": "0.0.29",
"@types/mocha": "^2.2.37",
"@types/node": "^7.0.0",
"@types/mocha": "^2.2.38",
"@types/node": "^7.0.4",
"@types/promises-a-plus": "0.0.27",
"@types/sinon": "^1.16.34",
"chai": "^3.4.1",
@ -52,10 +52,10 @@
"gulp-rename": "^1.2.2",
"gulp-replace": "^0.5.4",
"gulp-shell": "^0.5.1",
"gulp-sourcemaps": "^2.3.1",
"gulp-sourcemaps": "^2.4.0",
"gulp-tslint": "^7.0.1",
"gulp-typescript": "^3.1.4",
"gulp-uglify": "^2.0.0",
"gulp-uglify": "^2.0.1",
"gulpclass": "0.1.1",
"mocha": "^3.2.0",
"mssql": "^3.3.0",
@ -67,9 +67,9 @@
"sinon-chai": "^2.8.0",
"sqlite3": "^3.1.8",
"ts-node": "^2.0.0",
"tslint": "^4.3.1",
"tslint": "^4.4.1",
"tslint-stylish": "^2.1.0-beta",
"typescript": "^2.1.1"
"typescript": "^2.1.5"
},
"dependencies": {
"app-root-path": "^2.0.1",

33
src/schema-builder/SchemaBuilder.ts
View File

@ -10,6 +10,7 @@ import {PrimaryKeySchema} from "./schema/PrimaryKeySchema";
import {ColumnMetadata} from "../metadata/ColumnMetadata";
import {IndexMetadata} from "../metadata/IndexMetadata";
import {EntityMetadata} from "../metadata/EntityMetadata";
import {PromiseUtils} from "../util/PromiseUtils";
/**
* Creates complete tables schemas in the database based on the entity metadatas.
@ -108,7 +109,7 @@ export class SchemaBuilder {
* Drops all (old) foreign keys that exist in the table schemas, but do not exist in the entity metadata.
*/
protected async dropOldForeignKeys(): Promise<void> {
await Promise.all(this.entityToSyncMetadatas.map(async metadata => {
await PromiseUtils.runInSequence(this.entityToSyncMetadatas, async metadata => {
const tableSchema = this.tableSchemas.find(table => table.name === metadata.table.name);
if (!tableSchema)
@ -128,7 +129,7 @@ export class SchemaBuilder {
// drop foreign keys from the database
await this.queryRunner.dropForeignKeys(tableSchema, foreignKeySchemasToDrop);
}));
});
}
/**
@ -137,7 +138,7 @@ export class SchemaBuilder {
* Primary key only can be created in conclusion with auto generated column.
*/
protected async createNewTables(): Promise<void> {
await Promise.all(this.entityToSyncMetadatas.map(async metadata => {
await PromiseUtils.runInSequence(this.entityToSyncMetadatas, async metadata => {
// check if table does not exist yet
const existTableSchema = this.tableSchemas.find(table => table.name === metadata.table.name);
if (existTableSchema)
@ -149,7 +150,7 @@ export class SchemaBuilder {
const tableSchema = new TableSchema(metadata.table.name, this.metadataColumnsToColumnSchemas(metadata.columns), true);
this.tableSchemas.push(tableSchema);
await this.queryRunner.createTable(tableSchema);
}));
});
}
/**
@ -157,7 +158,7 @@ export class SchemaBuilder {
* We drop their keys too, since it should be safe.
*/
protected dropRemovedColumns() {
return Promise.all(this.entityToSyncMetadatas.map(async metadata => {
return PromiseUtils.runInSequence(this.entityToSyncMetadatas, async metadata => {
const tableSchema = this.tableSchemas.find(table => table.name === metadata.table.name);
if (!tableSchema) return;
@ -186,7 +187,7 @@ export class SchemaBuilder {
// drop columns from the database
await this.queryRunner.dropColumns(tableSchema, droppedColumnSchemas);
}));
});
}
/**
@ -194,7 +195,7 @@ export class SchemaBuilder {
* Columns are created without keys.
*/
protected addNewColumns() {
return Promise.all(this.entityToSyncMetadatas.map(async metadata => {
return PromiseUtils.runInSequence(this.entityToSyncMetadatas, async metadata => {
const tableSchema = this.tableSchemas.find(table => table.name === metadata.table.name);
if (!tableSchema)
return;
@ -212,7 +213,7 @@ export class SchemaBuilder {
const newColumnSchemas = this.metadataColumnsToColumnSchemas(newColumnMetadatas);
await this.queryRunner.addColumns(tableSchema, newColumnSchemas);
tableSchema.addColumns(newColumnSchemas);
}));
});
}
/**
@ -220,7 +221,7 @@ export class SchemaBuilder {
* Still don't create keys. Also we don't touch foreign keys of the changed columns.
*/
protected updateExistColumns() {
return Promise.all(this.entityToSyncMetadatas.map(async metadata => {
return PromiseUtils.runInSequence(this.entityToSyncMetadatas, async metadata => {
const tableSchema = this.tableSchemas.find(table => table.name === metadata.table.name);
if (!tableSchema)
return;
@ -260,14 +261,14 @@ export class SchemaBuilder {
});
return this.queryRunner.changeColumns(tableSchema, newAndOldColumnSchemas);
}));
});
}
/**
* Creates primary keys which does not exist in the table yet.
*/
protected updatePrimaryKeys() {
return Promise.all(this.entityToSyncMetadatas.map(async metadata => {
return PromiseUtils.runInSequence(this.entityToSyncMetadatas, async metadata => {
const tableSchema = this.tableSchemas.find(table => table.name === metadata.table.name && !table.justCreated);
if (!tableSchema)
return;
@ -290,14 +291,14 @@ export class SchemaBuilder {
tableSchema.addPrimaryKeys(addedKeys);
tableSchema.removePrimaryKeys(droppedKeys);
await this.queryRunner.updatePrimaryKeys(tableSchema);
}));
});
}
/**
* Creates foreign keys which does not exist in the table yet.
*/
protected createForeignKeys() {
return Promise.all(this.entityToSyncMetadatas.map(async metadata => {
return PromiseUtils.runInSequence(this.entityToSyncMetadatas, async metadata => {
const tableSchema = this.tableSchemas.find(table => table.name === metadata.table.name);
if (!tableSchema)
return;
@ -312,7 +313,7 @@ export class SchemaBuilder {
this.logger.logSchemaBuild(`creating a foreign keys: ${newKeys.map(key => key.name).join(", ")}`);
await this.queryRunner.createForeignKeys(tableSchema, dbForeignKeys);
tableSchema.addForeignKeys(dbForeignKeys);
}));
});
}
/**
@ -321,7 +322,7 @@ export class SchemaBuilder {
*/
protected createIndices() {
// return Promise.all(this.entityMetadatas.map(metadata => this.createIndices(metadata.table, metadata.indices)));
return Promise.all(this.entityToSyncMetadatas.map(async metadata => {
return PromiseUtils.runInSequence(this.entityToSyncMetadatas, async metadata => {
const tableSchema = this.tableSchemas.find(table => table.name === metadata.table.name);
if (!tableSchema)
return;
@ -346,7 +347,7 @@ export class SchemaBuilder {
});
await Promise.all(dropQueries.concat(addQueries));
}));
});
}
/**

211
test/functional/persistence/cascade-operations/cascade-operations.ts
View File

@ -1,211 +0,0 @@
import "reflect-metadata";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
describe("persistence > cascade operations", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true,
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
describe.skip("cascade insert", function() {
it("should work perfectly", () => Promise.all(connections.map(async connection => {
// create category
const category1 = new Category();
category1.name = "Category saved by cascades #1";
// category1.onePost = post1;
// create category
const category2 = new Category();
category2.name = "Category saved by cascades #2";
// category1.onePost = post1;
// create post
const post1 = new Post();
post1.title = "Hello Post #1";
post1.oneCategory = category1;
// todo(next): check out to one
// create photos
/*const photo1 = new Photo();
photo1.url = "http://me.com/photo";
photo1.post = post1;
photo1.categories = [category1, category2];
const photo2 = new Photo();
photo2.url = "http://me.com/photo";
photo2.post = post1;*/
// category1.photos = [photo1, photo2];
// post1.category = category1;
// post1.category.photos = [photo1, photo2];
await connection.entityManager.persist(post1);
console.log("********************************************************");
console.log("updating: ", post1);
console.log("********************************************************");
post1.title = "updated post #1";
post1.oneCategory.name = "updated category";
await connection.entityManager.persist(post1);
console.log("********************************************************");
console.log("removing: ", post1);
console.log("********************************************************");
await connection.entityManager.remove(post1);
// await connection.entityManager.persist(post1);
console.log("********************************************************");
/*const posts = await connection.entityManager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.category", "category")
// .innerJoinAndSelect("post.photos", "photos")
.getResults();
posts[0].title = "Updated Post #1";
console.log("********************************************************");
console.log("posts: ", posts);
// posts[0].category = null; // todo: uncomment to check remove
console.log("removing post's category: ", posts[0]);
await connection.entityManager.persist(posts[0]);*/
/* await connection.entityManager.persist([photo1, photo2]);
post1.photos = [photo1];
await connection.entityManager.persist(post1);
console.log("********************************************************");
console.log("********************************************************");
post1.photos = [photo1, photo2];
await connection.entityManager.persist(post1);
console.log("********************************************************");
console.log("********************************************************");
post1.title = "Updated Post";
await connection.entityManager.persist(post1);*/
})));
it("should insert entity when cascade option is set", () => Promise.all(connections.map(async connection => {
// create first category and post and save them
const category1 = new Category();
category1.name = "Category saved by cascades #1";
const post1 = new Post();
post1.title = "Hello Post #1";
post1.category = category1;
await connection.entityManager.persist(post1);
// create second category and post and save them
const category2 = new Category();
category2.name = "Category saved by cascades #2";
const post2 = new Post();
post2.title = "Hello Post #2";
post2.category = category2;
await connection.entityManager.persist(post2);
// now check
const posts = await connection.entityManager.find(Post, {
alias: "post",
innerJoinAndSelect: {
category: "post.category"
},
orderBy: {
"post.id": "ASC"
}
});
posts.should.be.eql([{
id: 1,
title: "Hello Post #1",
category: {
id: 1,
name: "Category saved by cascades #1"
}
}, {
id: 2,
title: "Hello Post #2",
category: {
id: 2,
name: "Category saved by cascades #2"
}
}]);
})));
it("should insert from inverse side when cascade option is set", () => Promise.all(connections.map(async connection => {
// create first post and category and save them
const post1 = new Post();
post1.title = "Hello Post #1";
const category1 = new Category();
category1.name = "Category saved by cascades #1";
category1.posts = [post1];
await connection.entityManager.persist(category1);
// create first post and category and save them
const post2 = new Post();
post2.title = "Hello Post #2";
const category2 = new Category();
category2.name = "Category saved by cascades #2";
category2.posts = [post2];
await connection.entityManager.persist(category2);
// now check
const posts = await connection.entityManager.find(Post, {
alias: "post",
innerJoinAndSelect: {
category: "post.category"
},
orderBy: {
"post.id": "ASC"
}
});
posts.should.be.eql([{
id: 1,
title: "Hello Post #1",
category: {
id: 1,
name: "Category saved by cascades #1"
}
}, {
id: 2,
title: "Hello Post #2",
category: {
id: 2,
name: "Category saved by cascades #2"
}
}]);
})));
});
});

50
test/functional/persistence/cascade-operations/entity/Category.ts
View File

@ -1,50 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {Post} from "./Post";
import {OneToMany} from "../../../../../src/decorator/relations/OneToMany";
import {Photo} from "./Photo";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
import {JoinTable} from "../../../../../src/decorator/relations/JoinTable";
import {ManyToOne} from "../../../../../src/decorator/relations/ManyToOne";
import {OneToOne} from "../../../../../src/decorator/relations/OneToOne";
import {JoinColumn} from "../../../../../src/decorator/relations/JoinColumn";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@OneToOne(type => Post, post => post.oneCategory, {
cascadeInsert: true,
cascadeUpdate: true,
cascadeRemove: true
})
@JoinColumn()
onePost: Post;
@OneToMany(type => Post, post => post.category, {
cascadeInsert: true,
cascadeUpdate: true
})
posts: Post[];
@ManyToMany(type => Photo, photo => photo.categories, {
cascadeInsert: true,
cascadeUpdate: true
})
@JoinTable()
photos: Photo[];
@ManyToOne(type => Photo, {
cascadeInsert: true,
cascadeUpdate: true,
cascadeRemove: true
})
photo: Photo|null;
}

32
test/functional/persistence/cascade-operations/entity/Photo.ts
View File

@ -1,32 +0,0 @@
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 {Post} from "../entity/Post";
import {Category} from "../entity/Category";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
@Entity()
export class Photo {
@PrimaryGeneratedColumn()
id: number;
@Column()
url: string;
@ManyToOne(type => Post, {
cascadeInsert: true,
cascadeUpdate: true,
cascadeRemove: true,
nullable: false
})
post: Post|null;
@ManyToMany(type => Category, category => category.photos, {
cascadeInsert: true,
cascadeUpdate: true
})
categories: Category[];
}

40
test/functional/persistence/cascade-operations/entity/Post.ts
View File

@ -1,40 +0,0 @@
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 {Category} from "./Category";
import {Photo} from "./Photo";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
import {JoinTable} from "../../../../../src/decorator/relations/JoinTable";
import {OneToOne} from "../../../../../src/decorator/relations/OneToOne";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@ManyToOne(type => Category, category => category.posts, {
cascadeInsert: true,
cascadeUpdate: true,
cascadeRemove: true
})
category: Category|null;
@ManyToMany(type => Photo, {
cascadeInsert: true,
cascadeUpdate: true
})
@JoinTable()
photos: Photo[];
@OneToOne(type => Category, category => category.onePost, {
cascadeInsert: true,
cascadeUpdate: true
})
oneCategory: Category;
}

55
test/functional/persistence/custom-column-name-pk/custom-column-name-pk.ts
View File

@ -1,55 +0,0 @@
import "reflect-metadata";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
describe("persistence > cascade operations with custom name", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true,
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
describe("cascade update", function() {
it("should remove relation", () => Promise.all(connections.map(async connection => {
// create first post and category and save them
const post1 = new Post();
post1.title = "Hello Post #1";
const category1 = new Category();
category1.name = "Category saved by cascades #1";
category1.posts = [post1];
await connection.entityManager.persist(category1);
category1.posts = [];
await connection.entityManager.persist(category1);
// now check
const posts = await connection.entityManager.find(Post, {
alias: "post",
leftJoinAndSelect: {
category: "post.category"
},
orderBy: {
"post.id": "ASC"
}
});
posts.should.be.eql([{
id: 1,
title: "Hello Post #1"
}]);
})));
});
});

21
test/functional/persistence/custom-column-name-pk/entity/Category.ts
View File

@ -1,21 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryColumn} from "../../../../../src/decorator/columns/PrimaryColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {Post} from "./Post";
import {OneToMany} from "../../../../../src/decorator/relations/OneToMany";
@Entity()
export class Category {
@PrimaryColumn("int", {generated: true, name: "theId"})
id: number;
@Column()
name: string;
@OneToMany(type => Post, post => post.category, {
cascadeInsert: true
})
posts: Post[];
}

21
test/functional/persistence/custom-column-name-pk/entity/Post.ts
View File

@ -1,21 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryColumn} from "../../../../../src/decorator/columns/PrimaryColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {ManyToOne} from "../../../../../src/decorator/relations/ManyToOne";
import {Category} from "./Category";
@Entity()
export class Post {
@PrimaryColumn("int", {generated: true, name: "theId"})
id: number;
@Column()
title: string;
@ManyToOne(type => Category, category => category.posts, {
cascadeInsert: true
})
category: Category;
}

31
test/functional/persistence/custom-column-names/entity/Category.ts
View File

@ -1,31 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Post} from "./Post";
import {Column} from "../../../../../src/decorator/columns/Column";
import {OneToMany} from "../../../../../src/decorator/relations/OneToMany";
import {OneToOne} from "../../../../../src/decorator/relations/OneToOne";
import {JoinColumn} from "../../../../../src/decorator/relations/JoinColumn";
import {CategoryMetadata} from "./CategoryMetadata";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@OneToMany(type => Post, post => post.category)
posts: Post[];
@Column({ type: "int", nullable: true })
metadataId: number;
@OneToOne(type => CategoryMetadata, metadata => metadata.category, {
cascadeInsert: true
})
@JoinColumn({ name: "metadataId" })
metadata: CategoryMetadata;
@Column()
name: string;
}

19
test/functional/persistence/custom-column-names/entity/CategoryMetadata.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 {OneToOne} from "../../../../../src/decorator/relations/OneToOne";
import {Category} from "./Category";
@Entity()
export class CategoryMetadata {
@PrimaryGeneratedColumn()
id: number;
@Column()
keyword: string;
@OneToOne(type => Category, category => category.metadata)
category: Category;
}

27
test/functional/persistence/custom-column-names/entity/Post.ts
View File

@ -1,27 +0,0 @@
import {Category} from "./Category";
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";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@Column("int", { nullable: true })
categoryId: number;
@ManyToOne(type => Category, category => category.posts, {
cascadeInsert: true,
cascadeUpdate: true
})
@JoinColumn({ name: "categoryId" })
category: Category;
}

244
test/functional/persistence/custom-column-names/persistence-custom-column-names.ts
View File

@ -1,244 +0,0 @@
import "reflect-metadata";
import {expect} from "chai";
import {Connection} from "../../../../src/connection/Connection";
import {Repository} from "../../../../src/repository/Repository";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
import {CategoryMetadata} from "./entity/CategoryMetadata";
import {setupConnection} from "../../../utils/test-utils";
describe("persistence > custom-column-names", function() {
// -------------------------------------------------------------------------
// Configuration
// -------------------------------------------------------------------------
// connect to db
let connection: Connection;
before(setupConnection(con => connection = con, [Post, Category, CategoryMetadata]));
after(() => connection.close());
// clean up database before each test
function reloadDatabase() {
return connection
.syncSchema(true)
.catch(e => {
console.log("Error during schema re-creation: ", e);
throw e;
});
}
let postRepository: Repository<Post>;
let categoryRepository: Repository<Category>;
let metadataRepository: Repository<CategoryMetadata>;
before(function() {
postRepository = connection.getRepository(Post);
categoryRepository = connection.getRepository(Category);
metadataRepository = connection.getRepository(CategoryMetadata);
});
// -------------------------------------------------------------------------
// Specifications
// -------------------------------------------------------------------------
describe("attach exist entity to exist entity with many-to-one relation", function() {
let newPost: Post, newCategory: Category, loadedPost: Post;
before(reloadDatabase);
// save a new category
before(function () {
newCategory = categoryRepository.create();
newCategory.name = "Animals";
return categoryRepository.persist(newCategory);
});
// save a new post
before(function() {
newPost = postRepository.create();
newPost.title = "All about animals";
return postRepository.persist(newPost);
});
// attach category to post and save it
before(function() {
newPost.category = newCategory;
return postRepository.persist(newPost);
});
// load a post
before(function() {
return postRepository
.findOneById(1, { alias: "post", leftJoinAndSelect: { category: "post.category" } })
.then(post => loadedPost = post!);
});
it("should contain attached category", function () {
expect(loadedPost).not.to.be.empty;
expect(loadedPost.category).not.to.be.empty;
expect(loadedPost.categoryId).not.to.be.empty;
});
});
describe("attach new entity to exist entity with many-to-one relation", function() {
let newPost: Post, newCategory: Category, loadedPost: Post;
before(reloadDatabase);
// save a new category
before(function () {
newCategory = categoryRepository.create();
newCategory.name = "Animals";
return categoryRepository.persist(newCategory);
});
// save a new post and attach category
before(function() {
newPost = postRepository.create();
newPost.title = "All about animals";
newPost.category = newCategory;
return postRepository.persist(newPost);
});
// load a post
before(function() {
return postRepository
.findOneById(1, { alias: "post", leftJoinAndSelect: { category: "post.category" } })
.then(post => loadedPost = post!);
});
it("should contain attached category", function () {
expect(loadedPost).not.to.be.empty;
expect(loadedPost.category).not.to.be.empty;
expect(loadedPost.categoryId).not.to.be.empty;
});
});
describe("attach new entity to new entity with many-to-one relation", function() {
let newPost: Post, newCategory: Category, loadedPost: Post;
before(reloadDatabase);
// save a new category, post and attach category to post
before(function () {
newCategory = categoryRepository.create();
newCategory.name = "Animals";
newPost = postRepository.create();
newPost.title = "All about animals";
newPost.category = newCategory;
return postRepository.persist(newPost);
});
// load a post
before(function() {
return postRepository
.findOneById(1, { alias: "post", leftJoinAndSelect: { category: "post.category" } })
.then(post => loadedPost = post!);
});
it("should contain attached category", function () {
expect(loadedPost).not.to.be.empty;
expect(loadedPost.category).not.to.be.empty;
expect(loadedPost.categoryId).not.to.be.empty;
});
});
describe("attach exist entity to exist entity with one-to-one relation", function() {
let newPost: Post, newCategory: Category, newMetadata: CategoryMetadata, loadedPost: Post;
before(reloadDatabase);
// save a new post
before(function() {
newPost = postRepository.create();
newPost.title = "All about animals";
return postRepository.persist(newPost);
});
// save a new category
before(function () {
newCategory = categoryRepository.create();
newCategory.name = "Animals";
return categoryRepository.persist(newCategory);
});
// save a new metadata
before(function() {
newMetadata = metadataRepository.create();
newMetadata.keyword = "animals";
return metadataRepository.persist(newMetadata);
});
// attach metadata to category and category to post and save it
before(function() {
newCategory.metadata = newMetadata;
newPost.category = newCategory;
return postRepository.persist(newPost);
});
// load a post
before(function() {
return postRepository
.findOneById(1, { alias: "post", leftJoinAndSelect: { category: "post.category", metadata: "category.metadata" } })
.then(post => loadedPost = post!);
});
it("should contain attached category and metadata in the category", function () {
expect(loadedPost).not.to.be.empty;
expect(loadedPost.category).not.to.be.empty;
expect(loadedPost.categoryId).not.to.be.empty;
expect(loadedPost.category.metadata).not.to.be.empty;
expect(loadedPost.category.metadataId).not.to.be.empty;
});
});
describe("attach new entity to exist entity with one-to-one relation", function() {
let newPost: Post, newCategory: Category, newMetadata: CategoryMetadata, loadedPost: Post;
before(reloadDatabase);
// save a new post
before(function() {
newPost = postRepository.create();
newPost.title = "All about animals";
return postRepository.persist(newPost);
});
// save a new category and new metadata
before(function () {
newMetadata = metadataRepository.create();
newMetadata.keyword = "animals";
newCategory = categoryRepository.create();
newCategory.name = "Animals";
newCategory.metadata = newMetadata;
return categoryRepository.persist(newCategory);
});
// attach metadata to category and category to post and save it
before(function() {
newPost.category = newCategory;
return postRepository.persist(newPost);
});
// load a post
before(function() {
return postRepository
.findOneById(1, { alias: "post", leftJoinAndSelect: { category: "post.category", metadata: "category.metadata" } })
.then(post => loadedPost = post!);
});
it("should contain attached category and metadata in the category", function () {
expect(loadedPost).not.to.be.empty;
expect(loadedPost.category).not.to.be.empty;
expect(loadedPost.categoryId).not.to.be.empty;
expect(loadedPost.category.metadata).not.to.be.empty;
expect(loadedPost.category.metadataId).not.to.be.empty;
});
});
});

78
test/functional/persistence/insert-operations/entity/Category.ts
View File

@ -1,78 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {Post} from "./Post";
import {OneToMany} from "../../../../../src/decorator/relations/OneToMany";
import {Photo} from "./Photo";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
import {JoinTable} from "../../../../../src/decorator/relations/JoinTable";
import {ManyToOne} from "../../../../../src/decorator/relations/ManyToOne";
import {OneToOne} from "../../../../../src/decorator/relations/OneToOne";
import {JoinColumn} from "../../../../../src/decorator/relations/JoinColumn";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@OneToMany(type => Post, post => post.manyToOneCategory, {
cascadeInsert: true,
cascadeUpdate: true
})
oneToManyPosts: Post[];
@OneToMany(type => Post, post => post.noCascadeManyToOneCategory, {
cascadeInsert: false,
cascadeUpdate: false
})
noCascadeOneToManyPosts: Post[];
@OneToOne(type => Post, post => post.oneToOneCategory, {
cascadeInsert: true,
cascadeUpdate: true,
cascadeRemove: true,
})
@JoinColumn()
oneToOneOwnerPost: Post;
@OneToOne(type => Post, post => post.noCascadeOneToOneCategory, {
cascadeInsert: false,
cascadeUpdate: false,
cascadeRemove: false,
})
@JoinColumn()
noCascadeOneToOnePost: Post;
@ManyToMany(type => Post, post => post.manyToManyOwnerCategories, {
cascadeInsert: true,
cascadeUpdate: true,
})
@JoinTable()
manyToManyPosts: Post[];
@ManyToMany(type => Post, post => post.noCascadeManyToManyOwnerCategories, {
cascadeInsert: false,
cascadeUpdate: false,
})
@JoinTable()
noCascadeManyToManyPosts: Post[];
@ManyToMany(type => Photo, {
cascadeInsert: true,
cascadeUpdate: true
})
@JoinTable()
photos: Photo[];
@ManyToOne(type => Photo, {
cascadeInsert: true,
cascadeUpdate: true,
cascadeRemove: true
})
photo: Photo|null;
}

31
test/functional/persistence/insert-operations/entity/Photo.ts
View File

@ -1,31 +0,0 @@
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 {Post} from "../entity/Post";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
@Entity()
export class Photo {
@PrimaryGeneratedColumn()
id: number;
@Column()
url: string;
@ManyToOne(type => Post, {
cascadeInsert: true,
cascadeUpdate: true,
cascadeRemove: true,
nullable: false
})
post: Post|null;
@ManyToMany(type => Post, photo => photo.photos, {
cascadeInsert: true,
cascadeUpdate: true,
})
posts: Post[];
}

76
test/functional/persistence/insert-operations/entity/Post.ts
View File

@ -1,76 +0,0 @@
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 {Category} from "./Category";
import {Photo} from "./Photo";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
import {JoinTable} from "../../../../../src/decorator/relations/JoinTable";
import {OneToOne} from "../../../../../src/decorator/relations/OneToOne";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@ManyToOne(type => Category, category => category.oneToManyPosts, {
cascadeInsert: true,
cascadeUpdate: true,
cascadeRemove: true,
})
manyToOneCategory: Category;
@ManyToOne(type => Category, category => category.noCascadeOneToManyPosts, {
cascadeInsert: false,
cascadeUpdate: false,
cascadeRemove: false,
})
noCascadeManyToOneCategory: Category;
@OneToOne(type => Category, category => category.oneToOneOwnerPost, {
cascadeInsert: true,
cascadeUpdate: true,
cascadeRemove: true,
})
oneToOneCategory: Category;
@OneToOne(type => Category, category => category.noCascadeOneToOnePost, {
cascadeInsert: false,
cascadeUpdate: false,
cascadeRemove: false,
})
noCascadeOneToOneCategory: Category;
@ManyToMany(type => Category, category => category.manyToManyPosts, {
cascadeInsert: true,
cascadeUpdate: true,
})
@JoinTable()
manyToManyOwnerCategories: Category[];
@ManyToMany(type => Category, category => category.noCascadeManyToManyPosts, {
cascadeInsert: false,
cascadeUpdate: false,
})
@JoinTable()
noCascadeManyToManyOwnerCategories: Category[];
@ManyToMany(type => Photo, photo => photo.posts, {
cascadeInsert: true,
cascadeUpdate: true,
})
@JoinTable()
photos: Photo[];
@ManyToMany(type => Photo, {
cascadeInsert: true,
cascadeUpdate: true,
})
@JoinTable()
noInversePhotos: Photo[];
}

85
test/functional/persistence/insert-operations/insert-operations.ts
View File

@ -1,85 +0,0 @@
import "reflect-metadata";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
describe.skip("persistence > insert operations", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true,
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
describe("cascade insert", function() {
it("should work perfectly", () => Promise.all(connections.map(async connection => {
// create category
const category1 = new Category();
category1.name = "Category saved by cascades #1";
// category1.onePost = post1;
// create post
const post1 = new Post();
post1.title = "Hello Post #1";
// todo(next): check out to one
// create photos
/* const photo1 = new Photo();
photo1.url = "http://me.com/photo";
photo1.post = post1;
const photo2 = new Photo();
photo2.url = "http://me.com/photo";
photo2.post = post1;*/
// post1.category = category1;
// post1.category.photos = [photo1, photo2];
await connection.entityManager.persist(post1);
await connection.entityManager.persist(category1);
console.log("********************************************************");
/*const posts = await connection.entityManager
.createQueryBuilder(Post, "post")
.leftJoinAndSelect("post.category", "category")
// .innerJoinAndSelect("post.photos", "photos")
.getResults();
posts[0].title = "Updated Post #1";
console.log("********************************************************");
console.log("posts: ", posts);
// posts[0].category = null; // todo: uncomment to check remove
console.log("removing post's category: ", posts[0]);
await connection.entityManager.persist(posts[0]);*/
/* await connection.entityManager.persist([photo1, photo2]);
post1.photos = [photo1];
await connection.entityManager.persist(post1);
console.log("********************************************************");
console.log("********************************************************");
post1.photos = [photo1, photo2];
await connection.entityManager.persist(post1);
console.log("********************************************************");
console.log("********************************************************");
post1.title = "Updated Post";
await connection.entityManager.persist(post1);*/
})));
});
});

19
test/functional/persistence/insert/update-relation-columns-after-insertion/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 {Post} from "./Post";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@OneToMany(type => Post, post => post.category)
posts: Post[];
}

19
test/functional/persistence/insert/update-relation-columns-after-insertion/entity/Post.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 {ManyToOne} from "../../../../../../src/decorator/relations/ManyToOne";
import {Category} from "./Category";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@ManyToOne(type => Category, category => category.posts)
category: Category;
}

36
test/functional/persistence/insert/update-relation-columns-after-insertion/update-relation-columns-after-insertion.ts
View File

@ -1,36 +0,0 @@
import "reflect-metadata";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
import {Connection} from "../../../../../src/connection/Connection";
import {createTestingConnections, reloadTestingDatabases, closeTestingConnections} from "../../../../utils/test-utils";
describe("persistence > insert > update-relation-columns-after-insertion", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true,
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
it("should work perfectly", () => Promise.all(connections.map(async connection => {
// create category
const category1 = new Category();
category1.name = "Category saved by cascades #1";
await connection.entityManager.persist(category1);
// create post
const post1 = new Post();
post1.title = "Hello Post #1";
post1.category = category1;
await connection.entityManager.persist(post1);
// todo: HERE FOR CALCULATIONS WE NEED TO CALCULATE OVERALL NUMBER OF QUERIES TO PREVENT EXTRA QUERIES
})));
});

19
test/functional/persistence/many-to-many/entity/Category.ts
View File

@ -1,19 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Post} from "./Post";
import {Column} from "../../../../../src/decorator/columns/Column";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@ManyToMany(type => Post, post => post.categories)
posts: Post[];
}

21
test/functional/persistence/many-to-many/entity/Post.ts
View File

@ -1,21 +0,0 @@
import {Category} from "./Category";
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
import {JoinTable} from "../../../../../src/decorator/relations/JoinTable";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@ManyToMany(type => Category, category => category.posts)
@JoinTable()
categories: Category[]|null;
}

19
test/functional/persistence/many-to-many/entity/User.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 {ManyToOne} from "../../../../../src/decorator/relations/ManyToOne";
import {Post} from "./Post";
@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@ManyToOne(type => Post, { cascadeUpdate: true })
post: Post;
}

66
test/functional/persistence/many-to-many/persistence-many-to-many.ts
View File

@ -1,66 +0,0 @@
import "reflect-metadata";
import {expect} from "chai";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
import {User} from "./entity/User";
import {createTestingConnections, reloadTestingDatabases, closeTestingConnections} from "../../../utils/test-utils";
describe("persistence > many-to-many", function() {
// -------------------------------------------------------------------------
// Configuration
// -------------------------------------------------------------------------
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
// -------------------------------------------------------------------------
// Specifications
// -------------------------------------------------------------------------
it("add exist element to exist object with empty one-to-many relation and save it and it should contain a new category", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
const userRepository = connection.getRepository(User);
// save a new category
const newCategory = categoryRepository.create();
newCategory.name = "Animals";
await categoryRepository.persist(newCategory);
// save a new post
const newPost = postRepository.create();
newPost.title = "All about animals";
await postRepository.persist(newPost);
// save a new user
const newUser = userRepository.create();
newUser.name = "Dima";
await userRepository.persist(newUser);
// now add a category to the post and attach post to a user and save a user
newPost.categories = [newCategory];
newUser.post = newPost;
await userRepository.persist(newUser);
// load a post
const loadedUser = await userRepository.findOneById(1, {
alias: "user",
leftJoinAndSelect: { post: "user.post", categories: "post.categories" }
});
expect(loadedUser!).not.to.be.empty;
expect(loadedUser!.post).not.to.be.empty;
expect(loadedUser!.post.categories).not.to.be.empty;
})));
});

20
test/functional/persistence/multi-primary-key-on-both-sides/entity/Category.ts
View File

@ -1,20 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryColumn} from "../../../../../src/decorator/columns/PrimaryColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {Post} from "./Post";
import {OneToMany} from "../../../../../src/decorator/relations/OneToMany";
@Entity()
export class Category {
@PrimaryColumn("int")
categoryId: number;
@Column()
name: string;
@OneToMany(type => Post, post => post.category)
posts: Post[];
}

22
test/functional/persistence/multi-primary-key-on-both-sides/entity/Post.ts
View File

@ -1,22 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryColumn} from "../../../../../src/decorator/columns/PrimaryColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {ManyToOne} from "../../../../../src/decorator/relations/ManyToOne";
import {Category} from "./Category";
@Entity()
export class Post {
@PrimaryColumn("int")
firstId: number;
@PrimaryColumn("int")
secondId: number;
@Column()
title: string;
@ManyToOne(type => Category, category => category.posts)
category: Category;
}

58
test/functional/persistence/multi-primary-key-on-both-sides/multi-primary-key.ts
View File

@ -1,58 +0,0 @@
import "reflect-metadata";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
describe("persistence > multi primary keys", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
describe("insert", function () {
it("should insert entity when when there are multi column primary keys", () => Promise.all(connections.map(async connection => {
const post1 = new Post();
post1.title = "Hello Post #1";
post1.firstId = 1;
post1.secondId = 2;
await connection.entityManager.persist(post1);
// create first category and post and save them
const category1 = new Category();
category1.categoryId = 123;
category1.name = "Category saved by cascades #1";
category1.posts = [post1];
await connection.entityManager.persist(category1);
// now check
const posts = await connection.entityManager.find(Post, {
alias: "post",
innerJoinAndSelect: {
category: "post.category"
},
orderBy: {
"post.firstId": "ASC"
}
});
posts.should.be.eql([{
firstId: 1,
secondId: 2,
title: "Hello Post #1",
category: {
categoryId: 123,
name: "Category saved by cascades #1"
}
}]);
})));
});
});

20
test/functional/persistence/multi-primary-key/entity/Category.ts
View File

@ -1,20 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryColumn} from "../../../../../src/decorator/columns/PrimaryColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {Post} from "./Post";
import {OneToMany} from "../../../../../src/decorator/relations/OneToMany";
@Entity()
export class Category {
@PrimaryColumn("int", {generated: true})
categoryId: number;
@Column()
name: string;
@OneToMany(type => Post, post => post.category)
posts: Post[];
}

22
test/functional/persistence/multi-primary-key/entity/Post.ts
View File

@ -1,22 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryColumn} from "../../../../../src/decorator/columns/PrimaryColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {ManyToOne} from "../../../../../src/decorator/relations/ManyToOne";
import {Category} from "./Category";
@Entity()
export class Post {
@PrimaryColumn("int")
firstId: number;
@PrimaryColumn("int")
secondId: number;
@Column()
title: string;
@ManyToOne(type => Category, category => category.posts)
category: Category;
}

65
test/functional/persistence/multi-primary-key/multi-primary-key.ts
View File

@ -1,65 +0,0 @@
import "reflect-metadata";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
describe("persistence > multi primary keys", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
describe("insert", function () {
it("should insert entity when when there are multi column primary keys", () => Promise.all(connections.map(async connection => {
const post1 = new Post();
post1.title = "Hello Post #1";
post1.firstId = 1;
post1.secondId = 2;
await connection.entityManager.persist(post1);
post1.should.be.eql({
firstId: 1,
secondId: 2,
title: "Hello Post #1"
});
// create first category and post and save them
const category1 = new Category();
category1.name = "Category saved by cascades #1";
category1.posts = [post1];
await connection.entityManager.persist(category1);
// now check
const posts = await connection.entityManager.find(Post, {
alias: "post",
innerJoinAndSelect: {
category: "post.category"
},
orderBy: {
"post.firstId": "ASC"
}
});
posts.should.be.eql([{
firstId: 1,
secondId: 2,
title: "Hello Post #1",
category: {
categoryId: 1,
name: "Category saved by cascades #1"
}
}]);
})));
});
});

19
test/functional/persistence/one-to-many/entity/Category.ts
View File

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

21
test/functional/persistence/one-to-many/entity/Post.ts
View File

@ -1,21 +0,0 @@
import {Category} from "./Category";
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {OneToMany} from "../../../../../src/decorator/relations/OneToMany";
import {Column} from "../../../../../src/decorator/columns/Column";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@OneToMany(type => Category, category => category.post)
categories: Category[]|null;
@Column({
default: "supervalue"
})
title: string;
}

178
test/functional/persistence/one-to-many/persistence-one-to-many.ts
View File

@ -1,178 +0,0 @@
import "reflect-metadata";
import {expect} from "chai";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
import {FindOptions} from "../../../../src/find-options/FindOptions";
import {closeTestingConnections, reloadTestingDatabases, createTestingConnections} from "../../../utils/test-utils";
describe("persistence > one-to-many", function() {
// -------------------------------------------------------------------------
// Setup
// -------------------------------------------------------------------------
let connections: Connection[];
before(() => {
return createTestingConnections({
entities: [Post, Category],
schemaCreate: true,
dropSchemaOnConnection: true,
}).then(all => connections = all);
});
after(() => closeTestingConnections(connections));
beforeEach(() => reloadTestingDatabases(connections));
// -------------------------------------------------------------------------
// Specifications
// -------------------------------------------------------------------------
describe("add exist element to exist object with empty one-to-many relation and save it", function() {
it("should contain a new category", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
let newCategory = categoryRepository.create();
newCategory.name = "Animals";
newCategory = await categoryRepository.persist(newCategory);
let newPost = postRepository.create();
newPost.title = "All about animals";
newPost = await postRepository.persist(newPost);
newPost.categories = [newCategory];
await postRepository.persist(newPost);
const findOptions: FindOptions = { alias: "post", innerJoinAndSelect: { categories: "post.categories" } };
const loadedPost = (await postRepository.findOneById(1, findOptions))!;
expect(loadedPost).not.to.be.empty;
expect(loadedPost.categories).not.to.be.empty;
expect(loadedPost.categories![0]).not.to.be.empty;
})));
});
describe("add exist element to new object with empty one-to-many relation and save it", function() {
it("should contain a new element", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
let newCategory = categoryRepository.create();
newCategory.name = "Animals";
newCategory = await categoryRepository.persist(newCategory);
let newPost = postRepository.create();
newPost.title = "All about animals";
newPost.categories = [newCategory];
await postRepository.persist(newPost);
const findOptions: FindOptions = { alias: "post", innerJoinAndSelect: { categories: "post.categories" } };
const loadedPost = await postRepository.findOneById(1, findOptions);
expect(loadedPost).not.to.be.empty;
expect(loadedPost!.categories).not.to.be.empty;
expect(loadedPost!.categories![0]).not.to.be.empty;
})));
});
describe("remove exist element from one-to-many relation and save it", function() {
it("should have only one category", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
let firstNewCategory = categoryRepository.create();
firstNewCategory.name = "Animals";
firstNewCategory = await categoryRepository.persist(firstNewCategory);
let secondNewCategory = categoryRepository.create();
secondNewCategory.name = "Insects";
secondNewCategory = await categoryRepository.persist(secondNewCategory);
let newPost = postRepository.create();
newPost.title = "All about animals";
await postRepository.persist(newPost);
newPost.categories = [firstNewCategory, secondNewCategory];
await postRepository.persist(newPost);
newPost.categories = [firstNewCategory];
await postRepository.persist(newPost);
const findOptions: FindOptions = { alias: "post", innerJoinAndSelect: { categories: "post.categories" } };
const loadedPost = await postRepository.findOneById(1, findOptions);
expect(loadedPost).not.to.be.empty;
expect(loadedPost!.categories).not.to.be.empty;
expect(loadedPost!.categories![0]).not.to.be.empty;
expect(loadedPost!.categories![1]).to.be.empty;
})));
});
describe("remove all elements from one-to-many relation and save it", function() {
it("should not have categories since they all are removed", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
let firstNewCategory = categoryRepository.create();
firstNewCategory.name = "Animals";
firstNewCategory = await categoryRepository.persist(firstNewCategory);
let secondNewCategory = categoryRepository.create();
secondNewCategory.name = "Insects";
secondNewCategory = await categoryRepository.persist(secondNewCategory);
let newPost = postRepository.create();
newPost.title = "All about animals";
await postRepository.persist(newPost);
newPost.categories = [firstNewCategory, secondNewCategory];
await postRepository.persist(newPost);
newPost.categories = [];
await postRepository.persist(newPost);
const findOptions: FindOptions = { alias: "post", leftJoinAndSelect: { categories: "post.categories" } };
const loadedPost = await postRepository.findOneById(1, findOptions);
expect(loadedPost).not.to.be.empty;
expect(loadedPost!.categories).to.be.empty;
})));
});
describe("set relation to null (elements exist there) from one-to-many relation and save it", function() {
it("should not have categories since they all are removed", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
let firstNewCategory = categoryRepository.create();
firstNewCategory.name = "Animals";
firstNewCategory = await categoryRepository.persist(firstNewCategory);
let secondNewCategory = categoryRepository.create();
secondNewCategory.name = "Insects";
secondNewCategory = await categoryRepository.persist(secondNewCategory);
let newPost = postRepository.create();
newPost.title = "All about animals";
await postRepository.persist(newPost);
newPost.categories = [firstNewCategory, secondNewCategory];
await postRepository.persist(newPost);
newPost.categories = null; // todo: what to do with undefined?
await postRepository.persist(newPost);
const findOptions: FindOptions = { alias: "post", leftJoinAndSelect: { categories: "post.categories" } };
const loadedPost = (await postRepository.findOneById(1, findOptions))!;
expect(loadedPost).not.to.be.empty;
expect(loadedPost.categories).to.be.empty;
})));
});
});

19
test/functional/persistence/persistence-order/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 {Post} from "./Post";
import {OneToOne} from "../../../../../src/decorator/relations/OneToOne";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@OneToOne(type => Post, post => post.category)
post: Post;
}

27
test/functional/persistence/persistence-order/entity/Details.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 {Post} from "./Post";
import {Photo} from "./Photo";
import {JoinColumn} from "../../../../../src/decorator/relations/JoinColumn";
@Entity()
export class Details {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@OneToOne(type => Post, post => post.details)
post: Post;
@OneToOne(type => Photo, photo => photo.details, {
nullable: false
})
@JoinColumn()
photo: Photo;
}

34
test/functional/persistence/persistence-order/entity/Photo.ts
View File

@ -1,34 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {Post} from "./Post";
import {OneToOne} from "../../../../../src/decorator/relations/OneToOne";
import {JoinColumn} from "../../../../../src/decorator/relations/JoinColumn";
import {Details} from "./Details";
import {Category} from "./Category";
@Entity()
export class Photo {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@OneToOne(type => Details, details => details.photo)
details: Details;
@OneToOne(type => Post, post => post.photo, {
nullable: false
})
@JoinColumn()
post: Post;
@OneToOne(type => Category, {
nullable: false
})
@JoinColumn()
category: Category;
}

34
test/functional/persistence/persistence-order/entity/Post.ts
View File

@ -1,34 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Column} from "../../../../../src/decorator/columns/Column";
import {Category} from "./Category";
import {OneToOne} from "../../../../../src/decorator/relations/OneToOne";
import {JoinColumn} from "../../../../../src/decorator/relations/JoinColumn";
import {Details} from "./Details";
import {Photo} from "./Photo";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@OneToOne(type => Category, category => category.post, {
nullable: true
})
@JoinColumn()
category: Category;
@OneToOne(type => Details, details => details.post, {
nullable: false
})
@JoinColumn()
details: Details;
@OneToOne(type => Photo, photo => photo.post)
photo: Photo;
}

72
test/functional/persistence/persistence-order/persistence-order.ts
View File

@ -1,72 +0,0 @@
import "reflect-metadata";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
describe("persistence > order of persistence execution operations", () => {
describe("should throw exception when non-resolvable circular relations found", function() {
it("should throw CircularRelationsError", () => createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true,
}).should.be.rejected); // CircularRelationsError
});
describe.skip("should persist all entities in correct order", function() {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true,
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
it("", () => Promise.all(connections.map(async connection => {
// create first category and post and save them
const category1 = new Category();
category1.name = "Category saved by cascades #1";
const post1 = new Post();
post1.title = "Hello Post #1";
post1.category = category1;
await connection.entityManager.persist(post1);
// now check
/*const posts = await connection.entityManager.find(Post, {
alias: "post",
innerJoinAndSelect: {
category: "post.category"
},
orderBy: {
"post.id": "ASC"
}
});
posts.should.be.eql([{
id: 1,
title: "Hello Post #1",
category: {
id: 1,
name: "Category saved by cascades #1"
}
}, {
id: 2,
title: "Hello Post #2",
category: {
id: 2,
name: "Category saved by cascades #2"
}
}]);*/
})));
});
});

27
test/functional/repository/basic-methods/entity/Blog.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 {Category} from "./Category";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
import {JoinTable} from "../../../../../src/decorator/relations/JoinTable";
@Entity()
export class Blog {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@Column()
text: string;
@ManyToMany(type => Category)
@JoinTable()
categories: Category[];
@Column()
counter: number = 0;
}

14
test/functional/repository/basic-methods/entity/Category.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 Category {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
}

14
test/functional/repository/basic-methods/entity/Post.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 Post {
@PrimaryGeneratedColumn()
id: number|undefined|null|string;
@Column()
title: string;
}

20
test/functional/repository/basic-methods/model-schema/QuestionSchema.ts
View File

@ -1,20 +0,0 @@
export default {
name: "Question",
table: {
name: "question"
},
columns: {
id: {
type: "int",
primary: true,
generated: true
},
title: {
type: "string",
nullable: false
}
},
target: function Question() {
this.type = "question";
}
};

5
test/functional/repository/basic-methods/model/Question.ts
View File

@ -1,5 +0,0 @@
export interface Question {
id?: number;
title?: string;
type: string;
}

5
test/functional/repository/basic-methods/model/User.ts
View File

@ -1,5 +0,0 @@
export interface User {
id?: number|null;
firstName?: string;
secondName?: string;
}

452
test/functional/repository/basic-methods/repository-basic-methods.ts
View File

@ -1,452 +0,0 @@
import "reflect-metadata";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {QueryBuilder} from "../../../../src/query-builder/QueryBuilder";
import {User} from "./model/User";
import questionSchema from "./model-schema/QuestionSchema";
import {Question} from "./model/Question";
import {Blog} from "./entity/Blog";
import {Category} from "./entity/Category";
describe("repository > basic methods", () => {
let userSchema: any;
try {
const resourceDir = __dirname + "/../../../../../../test/functional/repository/basic-methods/";
userSchema = require(resourceDir + "schema/user.json");
} catch (err) {
const resourceDir = __dirname + "/";
userSchema = require(resourceDir + "schema/user.json");
}
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [Post, Blog, Category],
entitySchemas: [userSchema, questionSchema],
schemaCreate: true,
dropSchemaOnConnection: true
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
describe("target", function() {
it("should return instance of the object it manages", () => connections.forEach(connection => {
const postRepository = connection.getRepository(Post);
postRepository.target.should.be.equal(Post);
const userRepository = connection.getRepository<User>("User");
userRepository.target.should.be.equal("User");
const questionRepository = connection.getRepository<Question>("Question");
questionRepository.target.should.be.instanceOf(Function);
}));
});
describe("hasId", function() {
it("should return true if entity has an id", () => connections.forEach(connection => {
const postRepository = connection.getRepository(Post);
const userRepository = connection.getRepository("User");
const postWithId = new Post();
postWithId.id = 1;
postWithId.title = "Hello post";
postRepository.hasId(postWithId).should.be.equal(true);
const postWithZeroId = new Post();
postWithZeroId.id = 0;
postWithZeroId.title = "Hello post";
postRepository.hasId(postWithZeroId).should.be.equal(true);
const userWithId: User = {
id: 1,
firstName: "Jonh",
secondName: "Doe"
};
userRepository.hasId(userWithId).should.be.equal(true);
const userWithZeroId: User = {
id: 1,
firstName: "Jonh",
secondName: "Doe"
};
userRepository.hasId(userWithZeroId).should.be.equal(true);
}));
it("should return false if entity does not have an id", () => connections.forEach(connection => {
const postRepository = connection.getRepository(Post);
const userRepository = connection.getRepository("User");
postRepository.hasId(null as any).should.be.equal(false);
postRepository.hasId(undefined as any).should.be.equal(false);
const postWithoutId = new Post();
postWithoutId.title = "Hello post";
postRepository.hasId(postWithoutId).should.be.equal(false);
const postWithUndefinedId = new Post();
postWithUndefinedId.id = undefined;
postWithUndefinedId.title = "Hello post";
postRepository.hasId(postWithUndefinedId).should.be.equal(false);
const postWithNullId = new Post();
postWithNullId.id = null;
postWithNullId.title = "Hello post";
postRepository.hasId(postWithNullId).should.be.equal(false);
const postWithEmptyId = new Post();
postWithEmptyId.id = "";
postWithEmptyId.title = "Hello post";
postRepository.hasId(postWithEmptyId).should.be.equal(false);
const userWithoutId: User = {
firstName: "Jonh",
secondName: "Doe"
};
userRepository.hasId(userWithoutId).should.be.equal(false);
const userWithNullId: User = {
id: null,
firstName: "Jonh",
secondName: "Doe"
};
userRepository.hasId(userWithNullId).should.be.equal(false);
const userWithUndefinedId: User = {
id: undefined,
firstName: "Jonh",
secondName: "Doe"
};
userRepository.hasId(userWithUndefinedId).should.be.equal(false);
}));
});
describe("createQueryBuilder", function() {
it("should create a new query builder with the given alias", () => connections.forEach(connection => {
const postRepository = connection.getRepository(Post);
const postQb = postRepository.createQueryBuilder("post");
postQb.should.be.instanceOf(QueryBuilder);
postQb.alias.should.be.equal("post");
const userRepository = connection.getRepository("User");
const userQb = userRepository.createQueryBuilder("user");
userQb.should.be.instanceOf(QueryBuilder);
userQb.alias.should.be.equal("user");
const questionRepository = connection.getRepository("Question");
const questionQb = questionRepository.createQueryBuilder("question");
questionQb.should.be.instanceOf(QueryBuilder);
questionQb.alias.should.be.equal("question");
}));
});
describe("create", function() {
it("should create a new instance of the object we are working with", () => connections.forEach(connection => {
const repository = connection.getRepository(Post);
repository.create().should.be.instanceOf(Post);
}));
it("should create a new empty object if entity schema is used", () => connections.forEach(connection => {
const repository = connection.getRepository("User");
repository.create().should.be.eql({});
}));
it("should create a new empty object if entity schema with a target is used", () => connections.forEach(connection => {
const repository = connection.getRepository<Question>("Question");
repository.create().should.not.be.empty;
repository.create().type.should.be.equal("question"); // make sure this is our Question function
}));
it("should create an entity and copy to it all properties of the given plain object if its given", () => connections.forEach(connection => {
const postRepository = connection.getRepository(Post);
const userRepository = connection.getRepository<User>("User");
const questionRepository = connection.getRepository<Question>("Question");
const plainPost = { id: 2, title: "Hello post" };
const post = postRepository.create(plainPost);
post.should.be.instanceOf(Post);
(post.id as number).should.be.equal(2);
post.title.should.be.equal("Hello post");
const plainUser = { id: 3, firstName: "John", secondName: "Doe" };
const user = userRepository.create(plainUser);
(user.id as number).should.be.equal(3);
(user.firstName as string).should.be.equal("John");
(user.secondName as string).should.be.equal("Doe");
const plainQuestion = { id: 3, title: "What is better?" };
const question = questionRepository.create(plainQuestion);
(question.id as number).should.be.equal(3);
(question.title as string).should.be.equal("What is better?");
}));
});
describe("createMany", function() {
it("should create entities and copy to them all properties of the given plain object if its given", () => connections.forEach(connection => {
const postRepository = connection.getRepository(Post);
const plainPosts = [{ id: 2, title: "Hello post" }, { id: 3, title: "Bye post" }];
const posts = postRepository.create(plainPosts);
posts.length.should.be.equal(2);
posts[0].should.be.instanceOf(Post);
(posts[0].id as number).should.be.equal(2);
posts[0].title.should.be.equal("Hello post");
posts[1].should.be.instanceOf(Post);
(posts[1].id as number).should.be.equal(3);
posts[1].title.should.be.equal("Bye post");
}));
});
describe("preload", function() {
it("should preload entity from the given object with only id", () => Promise.all(connections.map(async connection => {
const blogRepository = connection.getRepository(Blog);
const categoryRepository = connection.getRepository(Category);
// save the category
const category = new Category();
category.name = "people";
await categoryRepository.persist(category);
// save the blog
const blog = new Blog();
blog.title = "About people";
blog.text = "Blog about good people";
blog.categories = [category];
await blogRepository.persist(blog);
// and preload it
const plainBlogWithId = { id: 1 };
const preloadedBlog = await blogRepository.preload(plainBlogWithId);
preloadedBlog.should.be.instanceOf(Blog);
preloadedBlog.id.should.be.equal(1);
preloadedBlog.title.should.be.equal("About people");
preloadedBlog.text.should.be.equal("Blog about good people");
})));
it("should preload entity and all relations given in the object", () => Promise.all(connections.map(async connection => {
const blogRepository = connection.getRepository(Blog);
const categoryRepository = connection.getRepository(Category);
// save the category
const category = new Category();
category.name = "people";
await categoryRepository.persist(category);
// save the blog
const blog = new Blog();
blog.title = "About people";
blog.text = "Blog about good people";
blog.categories = [category];
await blogRepository.persist(blog);
// and preload it
const plainBlogWithId = { id: 1, categories: [{ id: 1 }] };
const preloadedBlog = await blogRepository.preload(plainBlogWithId);
preloadedBlog.should.be.instanceOf(Blog);
preloadedBlog.id.should.be.equal(1);
preloadedBlog.title.should.be.equal("About people");
preloadedBlog.text.should.be.equal("Blog about good people");
preloadedBlog.categories[0].id.should.be.equal(1);
preloadedBlog.categories[0].name.should.be.equal("people");
})));
});
describe("merge", function() {
it("should merge multiple entities", () => Promise.all(connections.map(async connection => {
const blogRepository = connection.getRepository(Blog);
// first entity
const blog1 = new Blog();
blog1.title = "First Blog";
// second entity
const blog2 = new Blog();
blog2.text = "text is from second blog";
// third entity
const category = new Category();
category.name = "category from third blog";
const blog3 = new Blog();
blog3.categories = [category];
const mergedBlog = blogRepository.merge(blog1, blog2, blog3);
mergedBlog.should.be.instanceOf(Blog);
mergedBlog.should.not.be.equal(blog1);
mergedBlog.should.not.be.equal(blog2);
mergedBlog.should.not.be.equal(blog3);
mergedBlog.title.should.be.equal("First Blog");
mergedBlog.text.should.be.equal("text is from second blog");
mergedBlog.categories[0].name.should.be.equal("category from third blog");
})));
it("should merge both entities and plain objects", () => Promise.all(connections.map(async connection => {
const blogRepository = connection.getRepository(Blog);
// first entity
const blog1 = { title: "First Blog" };
// second entity
const blog2 = { text: "text is from second blog" };
// third entity
const blog3 = new Blog();
blog3.categories = [{ name: "category from third blog" } as Category];
const mergedBlog = blogRepository.merge(blog1, blog2, blog3);
mergedBlog.should.be.instanceOf(Blog);
mergedBlog.should.not.be.equal(blog1);
mergedBlog.should.not.be.equal(blog2);
mergedBlog.should.not.be.equal(blog3);
mergedBlog.title.should.be.equal("First Blog");
mergedBlog.text.should.be.equal("text is from second blog");
mergedBlog.categories[0].name.should.be.equal("category from third blog");
})));
});
describe("using preload and merge together", function() {
it("if we preload entity from the plain object and merge preloaded object with plain object we'll have an object from the db with the replaced properties by a plain object's properties", () => Promise.all(connections.map(async connection => {
const blogRepository = connection.getRepository(Blog);
const categoryRepository = connection.getRepository(Category);
// save first category
const firstCategory = new Category();
firstCategory.name = "people";
await categoryRepository.persist(firstCategory);
// save second category
const secondCategory = new Category();
secondCategory.name = "animals";
await categoryRepository.persist(secondCategory);
// save the blog
const blog = new Blog();
blog.title = "About people";
blog.text = "Blog about good people";
blog.categories = [firstCategory, secondCategory];
await blogRepository.persist(blog);
// and preload it
const plainBlogWithId = { id: 1, title: "changed title about people", categories: [ { id: 1 }, { id: 2, name: "insects" } ] };
const preloadedBlog = await blogRepository.preload(plainBlogWithId);
const mergedBlog = blogRepository.merge(preloadedBlog, plainBlogWithId);
mergedBlog.should.be.instanceOf(Blog);
mergedBlog.id.should.be.equal(1);
mergedBlog.title.should.be.equal("changed title about people");
mergedBlog.text.should.be.equal("Blog about good people");
mergedBlog.categories[0].id.should.be.equal(1);
mergedBlog.categories[0].name.should.be.equal("people");
mergedBlog.categories[1].id.should.be.equal(2);
mergedBlog.categories[1].name.should.be.equal("insects");
})));
});
describe("query", function() {
it("should execute the query natively and it should return the result", () => Promise.all(connections.map(async connection => {
const repository = connection.getRepository(Blog);
const promises: Promise<Blog>[] = [];
for (let i = 0; i < 5; i++) { // todo: should pass with 50 items. find the problem
const blog = new Blog();
blog.title = "hello blog";
blog.text = "hello blog #" + i;
blog.counter = i * 100;
promises.push(repository.persist(blog));
}
await Promise.all(promises);
// such simple query should work on all platforms, isn't it? If no - make requests specifically to platforms
const result = await repository.query("SELECT MAX(blog.counter) as max from blog blog");
result[0].should.not.be.empty;
result[0].max.should.not.be.empty;
})));
});
describe.skip("transaction", function() {
it("executed queries must success", () => Promise.all(connections.map(async connection => {
const repository = connection.getRepository(Blog);
let blogs = await repository.find();
blogs.should.be.eql([]);
const blog = new Blog();
blog.title = "hello blog title";
blog.text = "hello blog text";
await repository.persist(blog);
blogs.should.be.eql([]);
blogs = await repository.find();
blogs.length.should.be.equal(1);
await repository.transaction(async () => {
const promises: Promise<Blog>[] = [];
for (let i = 0; i < 100; i++) {
const blog = new Blog();
blog.title = "hello blog";
blog.text = "hello blog #" + i;
blog.counter = i * 100;
promises.push(repository.persist(blog));
}
await Promise.all(promises);
blogs = await repository.find();
blogs.length.should.be.equal(101);
});
blogs = await repository.find();
blogs.length.should.be.equal(101);
})));
it("executed queries must rollback in the case if error in transaction", () => Promise.all(connections.map(async connection => {
const repository = connection.getRepository(Blog);
let blogs = await repository.find();
blogs.should.be.eql([]);
const blog = new Blog();
blog.title = "hello blog title";
blog.text = "hello blog text";
await repository.persist(blog);
blogs.should.be.eql([]);
blogs = await repository.find();
blogs.length.should.be.equal(1);
await repository.transaction(async () => {
const promises: Promise<Blog>[] = [];
for (let i = 0; i < 100; i++) {
const blog = new Blog();
blog.title = "hello blog";
blog.text = "hello blog #" + i;
blog.counter = i * 100;
promises.push(repository.persist(blog));
}
await Promise.all(promises);
blogs = await repository.find();
blogs.length.should.be.equal(101);
// now send the query that will crash all for us
throw new Error("this error will cancel all persist operations");
}).should.be.rejected;
blogs = await repository.find();
blogs.length.should.be.equal(1);
})));
});
});

21
test/functional/repository/basic-methods/schema/user.json
View File

@ -1,21 +0,0 @@
{
"name": "User",
"table": {
"name": "user"
},
"columns": {
"id": {
"type": "int",
"primary": true,
"generated": true
},
"firstName": {
"type": "string",
"nullable": false
},
"secondName": {
"type": "string",
"nullable": false
}
}
}

14
test/functional/repository/clear/entity/Post.ts
View File

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

68
test/functional/repository/clear/repostiory-clear.ts
View File

@ -1,68 +0,0 @@
import "reflect-metadata";
import {expect} from "chai";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
describe("repository > clear method", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [Post],
schemaCreate: true,
dropSchemaOnConnection: true
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
it("should remove everything", () => Promise.all(connections.map(async connection => {
// save dummy data
const promises: Promise<Post>[] = [];
for (let i = 0; i < 100; i++) {
const post = new Post();
post.id = i;
post.title = "post #" + i;
promises.push(connection.entityManager.persist(post));
}
await Promise.all(promises);
// check if they all are saved
const loadedPosts = await connection.entityManager.find(Post);
loadedPosts.should.be.instanceOf(Array);
loadedPosts.length.should.be.equal(100);
await connection.getRepository(Post).clear();
// check find method
const loadedPostsAfterClear = await connection.entityManager.find(Post);
loadedPostsAfterClear.should.be.instanceOf(Array);
loadedPostsAfterClear.length.should.be.equal(0);
})));
it("called from entity managed should remove everything as well", () => Promise.all(connections.map(async connection => {
// save dummy data
const promises: Promise<Post>[] = [];
for (let i = 0; i < 100; i++) {
const post = new Post();
post.id = i;
post.title = "post #" + i;
promises.push(connection.entityManager.persist(post));
}
await Promise.all(promises);
// check if they all are saved
const loadedPosts = await connection.entityManager.find(Post);
loadedPosts.should.be.instanceOf(Array);
loadedPosts.length.should.be.equal(100);
await connection.entityManager.clear(Post);
// check find method
const loadedPostsAfterClear = await connection.entityManager.find(Post);
loadedPostsAfterClear.should.be.instanceOf(Array);
loadedPostsAfterClear.length.should.be.equal(0);
})));
});

14
test/functional/repository/delete-by-id-and-ids/entity/Post.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 Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
}

96
test/functional/repository/delete-by-id-and-ids/repository-remove-by-id-and-ids.ts
View File

@ -1,96 +0,0 @@
import "reflect-metadata";
import {expect} from "chai";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {createTestingConnections, reloadTestingDatabases, closeTestingConnections} from "../../../utils/test-utils";
describe("repository > removeById and removeByIds methods", function() {
// -------------------------------------------------------------------------
// Configuration
// -------------------------------------------------------------------------
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
// -------------------------------------------------------------------------
// Specifications
// -------------------------------------------------------------------------
it("remove using removeById method should delete successfully", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const specificPostRepository = connection.getSpecificRepository(Post);
// save a new posts
const newPost1 = postRepository.create();
newPost1.title = "Super post #1";
const newPost2 = postRepository.create();
newPost2.title = "Super post #2";
const newPost3 = postRepository.create();
newPost3.title = "Super post #3";
const newPost4 = postRepository.create();
newPost4.title = "Super post #4";
await Promise.all([
postRepository.persist(newPost1),
postRepository.persist(newPost2),
postRepository.persist(newPost3),
postRepository.persist(newPost4)
]);
// remove one
await specificPostRepository.removeById(1);
// load to check
const loadedPosts = await postRepository.find();
// assert
loadedPosts.length.should.be.equal(3);
expect(loadedPosts.find(p => p.id === 1)).to.be.empty;
expect(loadedPosts.find(p => p.id === 2)).not.to.be.empty;
expect(loadedPosts.find(p => p.id === 3)).not.to.be.empty;
expect(loadedPosts.find(p => p.id === 4)).not.to.be.empty;
})));
it("remove using removeByIds method should delete successfully", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const specificPostRepository = connection.getSpecificRepository(Post);
// save a new posts
const newPost1 = postRepository.create();
newPost1.title = "Super post #1";
const newPost2 = postRepository.create();
newPost2.title = "Super post #2";
const newPost3 = postRepository.create();
newPost3.title = "Super post #3";
const newPost4 = postRepository.create();
newPost4.title = "Super post #4";
await Promise.all([
postRepository.persist(newPost1),
postRepository.persist(newPost2),
postRepository.persist(newPost3),
postRepository.persist(newPost4)
]);
// remove multiple
await specificPostRepository.removeByIds([2, 3]);
// load to check
const loadedPosts = await postRepository.find();
// assert
loadedPosts.length.should.be.equal(2);
expect(loadedPosts.find(p => p.id === 1)).not.to.be.empty;
expect(loadedPosts.find(p => p.id === 2)).to.be.empty;
expect(loadedPosts.find(p => p.id === 3)).to.be.empty;
expect(loadedPosts.find(p => p.id === 4)).not.to.be.empty;
})));
});

20
test/functional/repository/find-methods/entity/Post.ts
View File

@ -1,20 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {Column} from "../../../../../src/decorator/columns/Column";
import {PrimaryColumn} from "../../../../../src/decorator/columns/PrimaryColumn";
@Entity()
export class Post {
@PrimaryColumn("int")
id: number;
@Column()
title: string;
@Column()
categoryName: string;
@Column()
isNew: boolean = false;
}

5
test/functional/repository/find-methods/model/User.ts
View File

@ -1,5 +0,0 @@
export interface User {
id: number;
firstName: string;
secondName: string;
}

376
test/functional/repository/find-methods/repostiory-find-methods.ts
View File

@ -1,376 +0,0 @@
import "reflect-metadata";
import {expect} from "chai";
import {createTestingConnections, closeTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {FindOptions} from "../../../../src/find-options/FindOptions";
import {User} from "./model/User";
describe("repository > find methods", () => {
let userSchema: any;
try {
const resourceDir = __dirname + "/../../../../../../test/functional/repository/find-methods/";
userSchema = require(resourceDir + "schema/user.json");
} catch (err) {
const resourceDir = __dirname + "/";
userSchema = require(resourceDir + "schema/user.json");
}
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [Post],
entitySchemas: [userSchema],
schemaCreate: true,
dropSchemaOnConnection: true
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
describe("find and findAndCount", function() {
it("should return everything when no criteria given", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const promises: Promise<Post>[] = [];
for (let i = 0; i < 100; i++) {
const post = new Post();
post.id = i;
post.title = "post #" + i;
post.categoryName = "other";
promises.push(postRepository.persist(post));
}
const savedPosts = await Promise.all(promises);
savedPosts.length.should.be.equal(100); // check if they all are saved
// check find method
const loadedPosts = await postRepository.find({ alias: "post", orderBy: { "post.id": "ASC" }});
loadedPosts.should.be.instanceOf(Array);
loadedPosts.length.should.be.equal(100);
loadedPosts[0].id.should.be.equal(0);
loadedPosts[0].title.should.be.equal("post #0");
loadedPosts[99].id.should.be.equal(99);
loadedPosts[99].title.should.be.equal("post #99");
// check findAndCount method
let [loadedPosts2, count] = await postRepository.findAndCount({ alias: "post", orderBy: { "post.id": "ASC" }});
count.should.be.equal(100);
loadedPosts2.should.be.instanceOf(Array);
loadedPosts2.length.should.be.equal(100);
loadedPosts2[0].id.should.be.equal(0);
loadedPosts2[0].title.should.be.equal("post #0");
loadedPosts2[99].id.should.be.equal(99);
loadedPosts2[99].title.should.be.equal("post #99");
})));
it("should return posts that match given criteria", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const promises: Promise<Post>[] = [];
for (let i = 1; i <= 100; i++) {
const post = new Post();
post.id = i;
post.title = "post #" + i;
post.categoryName = i % 2 === 0 ? "even" : "odd";
promises.push(postRepository.persist(post));
}
const savedPosts = await Promise.all(promises);
savedPosts.length.should.be.equal(100); // check if they all are saved
// check find method
const loadedPosts = await postRepository.find({ categoryName: "odd" }, { alias: "post", orderBy: { "post.id": "ASC" }});
loadedPosts.should.be.instanceOf(Array);
loadedPosts.length.should.be.equal(50);
loadedPosts[0].id.should.be.equal(1);
loadedPosts[0].title.should.be.equal("post #1");
loadedPosts[49].id.should.be.equal(99);
loadedPosts[49].title.should.be.equal("post #99");
// check findAndCount method
let [loadedPosts2, count] = await postRepository.findAndCount({ categoryName: "odd" }, { alias: "post", orderBy: { "post.id": "ASC" }});
count.should.be.equal(50);
loadedPosts2.should.be.instanceOf(Array);
loadedPosts2.length.should.be.equal(50);
loadedPosts2[0].id.should.be.equal(1);
loadedPosts2[0].title.should.be.equal("post #1");
loadedPosts2[49].id.should.be.equal(99);
loadedPosts2[49].title.should.be.equal("post #99");
})));
it("should return posts that match given multiple criteria", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const promises: Promise<Post>[] = [];
for (let i = 1; i <= 100; i++) {
const post = new Post();
post.id = i;
post.title = "post #" + i;
post.categoryName = i % 2 === 0 ? "even" : "odd";
post.isNew = i > 90;
promises.push(postRepository.persist(post));
}
const savedPosts = await Promise.all(promises);
savedPosts.length.should.be.equal(100); // check if they all are saved
// check find method
const loadedPosts = await postRepository.find({ categoryName: "odd", isNew: true }, { alias: "post", orderBy: { "post.id": "ASC" }});
loadedPosts.should.be.instanceOf(Array);
loadedPosts.length.should.be.equal(5);
loadedPosts[0].id.should.be.equal(91);
loadedPosts[0].title.should.be.equal("post #91");
loadedPosts[4].id.should.be.equal(99);
loadedPosts[4].title.should.be.equal("post #99");
// check findAndCount method
let [loadedPosts2, count] = await postRepository.findAndCount({ categoryName: "odd", isNew: true }, { alias: "post", orderBy: { "post.id": "ASC" }});
count.should.be.equal(5);
loadedPosts2.should.be.instanceOf(Array);
loadedPosts2.length.should.be.equal(5);
loadedPosts2[0].id.should.be.equal(91);
loadedPosts2[0].title.should.be.equal("post #91");
loadedPosts2[4].id.should.be.equal(99);
loadedPosts2[4].title.should.be.equal("post #99");
})));
it("should return posts that match given find options", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const promises: Promise<Post>[] = [];
for (let i = 1; i <= 100; i++) {
const post = new Post();
post.id = i;
post.isNew = i > 90;
post.title = post.isNew ? "new post #" + i : "post #" + i;
post.categoryName = i % 2 === 0 ? "even" : "odd";
promises.push(postRepository.persist(post));
}
const savedPosts = await Promise.all(promises);
savedPosts.length.should.be.equal(100); // check if they all are saved
const findOptions: FindOptions = {
alias: "post",
where: "post.title LIKE :likeTitle AND post.categoryName = :categoryName",
parameters: {
likeTitle: "new post #%",
categoryName: "even"
},
orderBy: {
"post.id": "ASC"
}
};
// check find method
const loadedPosts = await postRepository.find(findOptions);
loadedPosts.should.be.instanceOf(Array);
loadedPosts.length.should.be.equal(5);
loadedPosts[0].id.should.be.equal(92);
loadedPosts[0].title.should.be.equal("new post #92");
loadedPosts[4].id.should.be.equal(100);
loadedPosts[4].title.should.be.equal("new post #100");
// check findAndCount method
let [loadedPosts2, count] = await postRepository.findAndCount(findOptions);
count.should.be.equal(5);
loadedPosts2.should.be.instanceOf(Array);
loadedPosts2.length.should.be.equal(5);
loadedPosts2[0].id.should.be.equal(92);
loadedPosts2[0].title.should.be.equal("new post #92");
loadedPosts2[4].id.should.be.equal(100);
loadedPosts2[4].title.should.be.equal("new post #100");
})));
it("should return posts that match both criteria and find options", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const promises: Promise<Post>[] = [];
for (let i = 1; i <= 100; i++) {
const post = new Post();
post.id = i;
post.isNew = i > 90;
post.title = post.isNew ? "new post #" + i : "post #" + i;
post.categoryName = i % 2 === 0 ? "even" : "odd";
promises.push(postRepository.persist(post));
}
const savedPosts = await Promise.all(promises);
savedPosts.length.should.be.equal(100); // check if they all are saved
const findOptions: FindOptions = {
alias: "post",
firstResult: 1,
maxResults: 2,
orderBy: {
"post.id": "ASC"
}
};
// check find method
const loadedPosts = await postRepository.find({ categoryName: "even", isNew: true }, findOptions);
loadedPosts.should.be.instanceOf(Array);
loadedPosts.length.should.be.equal(2);
loadedPosts[0].id.should.be.equal(94);
loadedPosts[0].title.should.be.equal("new post #94");
loadedPosts[1].id.should.be.equal(96);
loadedPosts[1].title.should.be.equal("new post #96");
// check findAndCount method
let [loadedPosts2, count] = await postRepository.findAndCount({ categoryName: "even", isNew: true }, findOptions);
count.should.be.equal(5);
loadedPosts2.should.be.instanceOf(Array);
loadedPosts2.length.should.be.equal(2);
loadedPosts2[0].id.should.be.equal(94);
loadedPosts2[0].title.should.be.equal("new post #94");
loadedPosts2[1].id.should.be.equal(96);
loadedPosts2[1].title.should.be.equal("new post #96");
})));
});
describe("findOne", function() {
it("should return first when no criteria given", () => Promise.all(connections.map(async connection => {
const userRepository = connection.getRepository<User>("User");
const promises: Promise<User>[] = [];
for (let i = 0; i < 100; i++) {
const user: User = {
id: i,
firstName: "name #" + i,
secondName: "Doe"
};
promises.push(userRepository.persist(user));
}
const savedUsers = await Promise.all(promises);
savedUsers.length.should.be.equal(100); // check if they all are saved
const loadedUser = (await userRepository.findOne({ alias: "user", orderBy: { "user.id": "ASC" }}))!;
loadedUser.id.should.be.equal(0);
loadedUser.firstName.should.be.equal("name #0");
loadedUser.secondName.should.be.equal("Doe");
})));
it("should return when criteria given", () => Promise.all(connections.map(async connection => {
const userRepository = connection.getRepository<User>("User");
const promises: Promise<User>[] = [];
for (let i = 0; i < 100; i++) {
const user: User = {
id: i,
firstName: "name #" + i,
secondName: "Doe"
};
promises.push(userRepository.persist(user));
}
const savedUsers = await Promise.all(promises);
savedUsers.length.should.be.equal(100); // check if they all are saved
const loadedUser = (await userRepository.findOne({ firstName: "name #1" }, { alias: "user", orderBy: { "user.id": "ASC" }}))!;
loadedUser.id.should.be.equal(1);
loadedUser.firstName.should.be.equal("name #1");
loadedUser.secondName.should.be.equal("Doe");
})));
it("should return when find options given", () => Promise.all(connections.map(async connection => {
const userRepository = connection.getRepository<User>("User");
const promises: Promise<User>[] = [];
for (let i = 0; i < 100; i++) {
const user: User = {
id: i,
firstName: "name #" + i,
secondName: "Doe"
};
promises.push(userRepository.persist(user));
}
const savedUsers = await Promise.all(promises);
savedUsers.length.should.be.equal(100); // check if they all are saved
const findOptions: FindOptions = {
alias: "user",
where: "user.firstName=:firstName AND user.secondName =:secondName",
parameters: {
firstName: "name #99",
secondName: "Doe"
}
};
const loadedUser = (await userRepository.findOne(findOptions, { alias: "user", orderBy: { "user.id": "ASC" }}))!;
loadedUser.id.should.be.equal(99);
loadedUser.firstName.should.be.equal("name #99");
loadedUser.secondName.should.be.equal("Doe");
})));
});
describe("findOneById", function() {
it("should return entity by a given id", () => Promise.all(connections.map(async connection => {
const userRepository = connection.getRepository<User>("User");
const promises: Promise<User>[] = [];
for (let i = 0; i < 100; i++) {
const user: User = {
id: i,
firstName: "name #" + i,
secondName: "Doe"
};
promises.push(userRepository.persist(user));
}
const savedUsers = await Promise.all(promises);
savedUsers.length.should.be.equal(100); // check if they all are saved
let loadedUser = (await userRepository.findOneById(0))!;
loadedUser.id.should.be.equal(0);
loadedUser.firstName.should.be.equal("name #0");
loadedUser.secondName.should.be.equal("Doe");
loadedUser = (await userRepository.findOneById(1))!;
loadedUser.id.should.be.equal(1);
loadedUser.firstName.should.be.equal("name #1");
loadedUser.secondName.should.be.equal("Doe");
loadedUser = (await userRepository.findOneById(99))!;
loadedUser.id.should.be.equal(99);
loadedUser.firstName.should.be.equal("name #99");
loadedUser.secondName.should.be.equal("Doe");
})));
it("should return entity by a given id and find options", () => Promise.all(connections.map(async connection => {
const userRepository = connection.getRepository<User>("User");
const promises: Promise<User>[] = [];
for (let i = 0; i < 100; i++) {
const user: User = {
id: i,
firstName: "name #" + i,
secondName: "Doe"
};
promises.push(userRepository.persist(user));
}
const findOptions1: FindOptions = {
alias: "user",
whereConditions: {
secondName: "Doe"
}
};
const findOptions2: FindOptions = {
alias: "user",
whereConditions: {
secondName: "Dorian"
}
};
const savedUsers = await Promise.all(promises);
savedUsers.length.should.be.equal(100); // check if they all are saved
let loadedUser = await userRepository.findOneById(0, findOptions1);
loadedUser!.id.should.be.equal(0);
loadedUser!.firstName.should.be.equal("name #0");
loadedUser!.secondName.should.be.equal("Doe");
loadedUser = await userRepository.findOneById(1, findOptions2);
expect(loadedUser).to.be.undefined;
})));
});
});

20
test/functional/repository/find-methods/schema/user.json
View File

@ -1,20 +0,0 @@
{
"name": "User",
"table": {
"name": "user"
},
"columns": {
"id": {
"type": "int",
"primary": true
},
"firstName": {
"type": "string",
"nullable": false
},
"secondName": {
"type": "string",
"nullable": false
}
}
}

23
test/functional/repository/set-add-remove-relations/entity/Category.ts
View File

@ -1,23 +0,0 @@
import {Entity} from "../../../../../src/decorator/entity/Entity";
import {PrimaryGeneratedColumn} from "../../../../../src/decorator/columns/PrimaryGeneratedColumn";
import {Post} from "./Post";
import {Column} from "../../../../../src/decorator/columns/Column";
import {ManyToOne} from "../../../../../src/decorator/relations/ManyToOne";
import {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
@Entity()
export class Category {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@ManyToOne(type => Post, post => post.categories)
post: Post;
@ManyToMany(type => Post, post => post.manyCategories)
manyPosts: Post[];
}

25
test/functional/repository/set-add-remove-relations/entity/Post.ts
View File

@ -1,25 +0,0 @@
import {Category} from "./Category";
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 {ManyToMany} from "../../../../../src/decorator/relations/ManyToMany";
import {JoinTable} from "../../../../../src/decorator/relations/JoinTable";
@Entity()
export class Post {
@PrimaryGeneratedColumn()
id: number;
@Column()
title: string;
@OneToMany(type => Category, category => category.post)
categories: Category[]|null;
@ManyToMany(type => Category, category => category.manyPosts)
@JoinTable()
manyCategories: Category[];
}

305
test/functional/repository/set-add-remove-relations/repository-set-add-remove-relations.ts
View File

@ -1,305 +0,0 @@
import "reflect-metadata";
import {expect} from "chai";
import {Connection} from "../../../../src/connection/Connection";
import {Post} from "./entity/Post";
import {Category} from "./entity/Category";
import {createTestingConnections, reloadTestingDatabases, closeTestingConnections} from "../../../utils/test-utils";
describe("repository > set/add/remove relation methods", function() {
// -------------------------------------------------------------------------
// Configuration
// -------------------------------------------------------------------------
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
schemaCreate: true,
dropSchemaOnConnection: true
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
// -------------------------------------------------------------------------
// Specifications
// -------------------------------------------------------------------------
it("add elements to many-to-many from owner side", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
const postSpecificRepository = connection.getSpecificRepository(Post);
// save a new category
const newCategory1 = categoryRepository.create();
newCategory1.name = "Animals";
await categoryRepository.persist(newCategory1);
// save a new category
const newCategory2 = categoryRepository.create();
newCategory2.name = "Kids";
await categoryRepository.persist(newCategory2);
// save a new post
const newPost = postRepository.create();
newPost.title = "Super post";
await postRepository.persist(newPost);
// add categories to a post
await postSpecificRepository.addToRelation(post => post.manyCategories, newPost.id, [newCategory1.id, newCategory2.id]);
// load a post, want to have categories count
const loadedPost = await postRepository
.findOneById(1, { alias: "post", leftJoinAndSelect: { manyCategories: "post.manyCategories" } });
expect(loadedPost!).not.to.be.empty;
expect(loadedPost!.manyCategories).not.to.be.empty;
expect(loadedPost!.manyCategories![0]).not.to.be.empty;
expect(loadedPost!.manyCategories![1]).not.to.be.empty;
})));
it("add elements to many-to-many from inverse side", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
const categorySpecificRepository = connection.getSpecificRepository(Category);
// save a new post
const newPost1 = postRepository.create();
newPost1.title = "post #1";
await postRepository.persist(newPost1);
// save a new post
const newPost2 = postRepository.create();
newPost2.title = "post #2";
await postRepository.persist(newPost2);
// save a new category
const newCategory = categoryRepository.create();
newCategory.name = "Kids";
await categoryRepository.persist(newCategory);
// add categories to a post
await categorySpecificRepository.addToRelation(category => category.manyPosts, newCategory.id, [newPost1.id, newPost2.id]);
// load a post, want to have categories count
const loadedCategory = await categoryRepository.findOneById(1, {
alias: "category",
leftJoinAndSelect: { manyPosts: "category.manyPosts" } }
);
expect(loadedCategory).not.to.be.empty;
expect(loadedCategory!.manyPosts).not.to.be.empty;
expect(loadedCategory!.manyPosts![0]).not.to.be.empty;
expect(loadedCategory!.manyPosts![1]).not.to.be.empty;
})));
it("remove elements to many-to-many from owner side", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
const postSpecificRepository = connection.getSpecificRepository(Post);
// save a new category
const newCategory1 = categoryRepository.create();
newCategory1.name = "Animals";
await categoryRepository.persist(newCategory1);
// save a new category
const newCategory2 = categoryRepository.create();
newCategory2.name = "Kids";
await categoryRepository.persist(newCategory2);
// save a new category
const newCategory3 = categoryRepository.create();
newCategory3.name = "Adults";
await categoryRepository.persist(newCategory3);
// save a new post with categories
const newPost = postRepository.create();
newPost.title = "Super post";
newPost.manyCategories = [newCategory1, newCategory2, newCategory3];
await postRepository.persist(newPost);
// add categories to a post
await postSpecificRepository.removeFromRelation(post => post.manyCategories, newPost.id, [newCategory1.id, newCategory3.id]);
// load a post, want to have categories count
const loadedPost = await postRepository.findOneById(1, {
alias: "post",
leftJoinAndSelect: { manyCategories: "post.manyCategories" }
});
expect(loadedPost!).not.to.be.empty;
expect(loadedPost!.manyCategories).not.to.be.empty;
loadedPost!.manyCategories.length.should.be.equal(1);
loadedPost!.manyCategories![0].name.should.be.equal("Kids");
})));
it("remove elements to many-to-many from inverse side", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
const categorySpecificRepository = connection.getSpecificRepository(Category);
// save a new category
const newPost1 = postRepository.create();
newPost1.title = "post #1";
await postRepository.persist(newPost1);
// save a new category
const newPost2 = postRepository.create();
newPost2.title = "post #2";
await postRepository.persist(newPost2);
// save a new category
const newPost3 = postRepository.create();
newPost3.title = "post #3";
await postRepository.persist(newPost3);
// save a new post with categories
const newCategory = categoryRepository.create();
newCategory.name = "SuperCategory";
newCategory.manyPosts = [newPost1, newPost2, newPost3];
await categoryRepository.persist(newCategory);
// add categories to a post
await categorySpecificRepository.removeFromRelation(post => post.manyPosts, newCategory.id, [newPost1.id, newPost3.id]);
// load a post, want to have categories count
const loadedCategory = await categoryRepository.findOneById(1, {
alias: "category",
leftJoinAndSelect: { manyPosts: "category.manyPosts" }
});
expect(loadedCategory!).not.to.be.empty;
expect(loadedCategory!.manyPosts).not.to.be.empty;
loadedCategory!.manyPosts.length.should.be.equal(1);
loadedCategory!.manyPosts[0].title.should.be.equal("post #2");
})));
it("set element to one-to-many relation", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
const postSpecificRepository = connection.getSpecificRepository(Post);
const categorySpecificRepository = connection.getSpecificRepository(Category);
// save a new category
const newCategory1 = categoryRepository.create();
newCategory1.name = "Animals";
await categoryRepository.persist(newCategory1);
// save a new post
const newPost = postRepository.create();
newPost.title = "Super post";
await postRepository.persist(newPost);
// add categories to a post
await postSpecificRepository.setRelation(post => post.categories, newPost.id, newCategory1.id);
// load a post, want to have categories count
const loadedPost = await postRepository.findOneById(1, {
alias: "post",
leftJoinAndSelect: { categories: "post.categories" }
});
expect(loadedPost!).not.to.be.empty;
expect(loadedPost!.categories).not.to.be.empty;
expect(loadedPost!.categories![0]).not.to.be.empty;
})));
it("set element to many-to-one relation", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
const categorySpecificRepository = connection.getSpecificRepository(Category);
// save a new category
const newPost = postRepository.create();
newPost.title = "post #1";
await postRepository.persist(newPost);
// save a new category
const newCategory = categoryRepository.create();
newCategory.name = "Kids";
await categoryRepository.persist(newCategory);
// add categories to a post
await categorySpecificRepository.setRelation(category => category.post, newCategory.id, newPost.id);
// load a post, want to have categories count
const loadedCategory = await categoryRepository.findOneById(1, {
alias: "category",
leftJoinAndSelect: { post: "category.post" }
});
expect(loadedCategory!).not.to.be.empty;
expect(loadedCategory!.post).not.to.be.empty;
})));
it("set element to NULL in one-to-many relation", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
const postSpecificRepository = connection.getSpecificRepository(Post);
// save a new category
const newCategory1 = categoryRepository.create();
newCategory1.name = "Animals";
await categoryRepository.persist(newCategory1);
// save a new post
const newPost = postRepository.create();
newPost.title = "Super post";
newPost.categories = [newCategory1];
await postRepository.persist(newPost);
// add categories to a post
await postSpecificRepository.setRelation(post => post.categories, newPost.id, null);
// load a post, want to have categories count
const loadedPost = await postRepository.findOneById(1, {
alias: "post",
leftJoinAndSelect: { categories: "post.categories" }
});
expect(loadedPost!).not.to.be.empty;
expect(loadedPost!.categories).to.be.empty;
})));
it("set element to NULL in many-to-one relation", () => Promise.all(connections.map(async connection => {
const postRepository = connection.getRepository(Post);
const categoryRepository = connection.getRepository(Category);
const categorySpecificRepository = connection.getSpecificRepository(Category);
// save a new category
const newPost = postRepository.create();
newPost.title = "post #1";
await postRepository.persist(newPost);
// save a new category
const newCategory = categoryRepository.create();
newCategory.name = "Kids";
newCategory.post = newPost;
await categoryRepository.persist(newCategory);
// add categories to a post
await categorySpecificRepository.setRelation(category => category.post, newCategory.id, null);
// load a post, want to have categories count
const loadedCategory = await categoryRepository.findOneById(1, {
alias: "category",
leftJoinAndSelect: { post: "category.post" }
});
expect(loadedCategory).not.to.be.empty;
expect(loadedCategory!.post).to.be.empty;
})));
});