@typetron/framework 0.5.3 → 0.5.4

package/tests/Database/Drivers/SqliteDriverTest.ts

@@ -0,0 +1,126 @@
+import { suite, test } from '@testdeck/mocha'
+import { BelongsTo, Column, Entity, HasOne, ID, Options, PrimaryColumn, Relation, SqliteDriver } from '@Typetron/Database'
+import { anyString, instance, mock, when } from '@Typetron/node_modules/ts-mockito'
+import { Schema } from '@Typetron/Database/Drivers/SQLite/Schema'
+import { expectQuery } from '@Typetron/tests/Database/utils'
+import { expect } from 'chai'
+import { DatabaseDriver } from '@Typetron/Database/Drivers/DatabaseDriver'
+
+@suite
+class SqliteDriverTest {
+
+    driver: DatabaseDriver
+    schema: Schema
+    query: string
+
+    async before() {
+        this.driver = mock(SqliteDriver)
+        this.schema = new Schema(instance(this.driver))
+        when(this.driver.run(anyString())).thenCall((query: string) => this.query = query)
+    }
+
+    @test
+    async createsEmptyTable() {
+        @Options()
+        class Test extends Entity {}
+
+        await this.schema.synchronize([Test].pluck('metadata'))
+        expectQuery(this.query).toEqual('CREATE TABLE test ( )')
+    }
+
+    @test
+    async createsTableWithIntegerColumn() {
+        class Test extends Entity {
+            @Column()
+            age: number
+        }
+
+        await this.schema.synchronize([Test].pluck('metadata'))
+        expectQuery(this.query).toEqual('CREATE TABLE test ( age integer )')
+    }
+
+    @test
+    async createsTableWithPrimaryAutoIncrementColumn() {
+        class Test extends Entity {
+            @PrimaryColumn()
+            id: ID
+        }
+
+        await this.schema.synchronize([Test].pluck('metadata'))
+        expectQuery(this.query).toEqual(`
+            CREATE TABLE test
+            (
+                id integer PRIMARY KEY AUTOINCREMENT
+            )
+        `)
+    }
+
+    @test
+    async createsTableWithForeignColumn() {
+        class User extends Entity {
+            @Column()
+            @Relation(() => Image, 'user')
+            image: HasOne<Image>
+        }
+
+        class Image extends Entity {
+            @Column()
+            @Relation(() => User, 'image')
+            user: BelongsTo<User>
+        }
+
+        await this.schema.synchronize([Image].pluck('metadata'))
+        expectQuery(this.query).toEqual(`
+            CREATE TABLE image
+            (
+                userId integer
+            )
+        `)
+    }
+
+    @test
+    async altersTable() {
+        when(this.driver.tableExists(anyString())).thenReturn(Promise.resolve(true))
+        when(this.driver.tableColumns(anyString())).thenReturn(Promise.resolve([
+            {
+                name: 'column2',
+                type: 'integer'
+            },
+            {
+                name: 'column3',
+                type: 'integer'
+            },
+        ]))
+
+        const queries: string[] = []
+        when(this.driver.run(anyString())).thenCall((query: string) => queries.push(query))
+
+        class User extends Entity {
+            @Column()
+            column1: number
+
+            @Column()
+            column2: string
+        }
+
+        await this.schema.synchronize([User].pluck('metadata'))
+
+        expect(queries).to.have.length(4)
+        expectQuery(queries[0]).toEqual(`
+            CREATE TABLE user_alter_tmp
+            (
+                column1 integer,
+                column2 varchar(255)
+            )
+        `)
+
+        expectQuery(queries[1]).toEqual(`
+            INSERT INTO user_alter_tmp(column2)
+            SELECT column2
+            FROM user
+        `)
+
+        expectQuery(queries[2]).toEqual(`DROP TABLE user`)
+        expectQuery(queries[3]).toEqual(`ALTER TABLE user_alter_tmp RENAME TO user`)
+    }
+}

package/tests/Database/Entities/Article.ts

@@ -0,0 +1,21 @@
+import { Column, Entity, PrimaryColumn, Relation } from '../../../Database'
+import { User } from './User'
+import { BelongsTo } from '../../../Database/Fields'
+
+export class Article extends Entity {
+
+    @PrimaryColumn()
+    id: number
+
+    @Column()
+    title: string
+
+    @Column()
+    content: string
+
+    @Column()
+    published: boolean = false
+
+    @Relation(() => User, 'articles')
+    author: BelongsTo<User>
+}

package/tests/Database/Entities/Profile.ts

@@ -0,0 +1,21 @@
+import { Column, CreatedAt, Entity, PrimaryColumn, Relation, UpdatedAt } from '../../../Database'
+import { User } from './User'
+import { BelongsTo } from '../../../Database/Fields'
+
+export class Profile extends Entity {
+
+    @PrimaryColumn()
+    id: number
+
+    @Relation(() => User, 'profile')
+    user: BelongsTo<User>
+
+    @Column()
+    address: string
+
+    @CreatedAt()
+    createdAt: Date
+
+    @UpdatedAt()
+    updatedAt: Date
+}

package/tests/Database/Entities/Role.ts

@@ -0,0 +1,15 @@
+import { Column, Entity, PrimaryColumn, Relation } from '../../../Database'
+import { User } from './User'
+import { BelongsToMany } from '../../../Database/Fields'
+
+export class Role extends Entity {
+
+    @PrimaryColumn()
+    id: number
+
+    @Column()
+    name: string
+
+    @Relation(() => User, 'roles')
+    users: BelongsToMany<User>
+}

package/tests/Database/Entities/User.ts

@@ -0,0 +1,35 @@
+import { Column, CreatedAt, Entity, Options, PrimaryColumn, Relation, UpdatedAt } from '../../../Database'
+import { Article } from './Article'
+import { Role } from './Role'
+import { Profile } from './Profile'
+import { BelongsToMany, HasMany, HasOne } from '../../../Database/Fields'
+
+@Options({
+    table: 'users'
+})
+export class User extends Entity {
+
+    @PrimaryColumn()
+    id: number
+
+    @Column()
+    name: string
+
+    @Column()
+    email: string
+
+    @Relation(() => Profile, 'user')
+    profile: HasOne<Profile>
+
+    @Relation(() => Article, 'author')
+    articles: HasMany<Article>
+
+    @Relation(() => Role, 'users')
+    roles: BelongsToMany<Role>
+
+    @CreatedAt()
+    createdAt: Date
+
+    @UpdatedAt()
+    updatedAt: Date
+}

package/tests/Database/EntityRelationshipsTest.ts

@@ -0,0 +1,475 @@
+import { suite, test } from '@testdeck/mocha'
+import { Connection, Entity, EntityConstructor, Query, SqliteDriver } from '../../Database'
+import { User } from './Entities/User'
+import { Article } from './Entities/Article'
+import { Role } from './Entities/Role'
+import { Profile } from './Entities/Profile'
+import { expect } from 'chai'
+import { BelongsTo, BelongsToMany, HasMany, HasOne } from '../../Database/Fields'
+
+@suite
+class EntityRelationshipsTest {
+    joe = {
+        name: 'Joe',
+        email: 'joe@example.com',
+    }
+
+    doe = {
+        name: 'Doe',
+        email: 'doe@example.com',
+    }
+
+    admin = {
+        name: 'Admin'
+    }
+    developer = {
+        name: 'Developer'
+    }
+
+    async before() {
+        Query.connection = new Connection(new SqliteDriver(':memory:'))
+        // Query.connection = new Connection(new MysqlDriver({
+        //     host: 'localhost', user: 'root', password: 'root', database: 'typetron_test'
+        // }))
+        await Query.connection.driver.schema.synchronize([User, Profile, Article, Role].pluck('metadata'))
+    }
+
+    async after() {
+        for await (const entity of [User, Profile, Article, Role]) {
+            await (entity as EntityConstructor<Entity>).truncate()
+        }
+
+        await Query.table('role_users').truncate()
+    }
+
+    @test
+    async hydratesEntityWithRelationships() {
+        const user = new User()
+
+        expect(user).to.haveOwnProperty('profile')
+        expect(user.profile).to.be.instanceOf(HasOne)
+        expect(user).to.haveOwnProperty('articles')
+        expect(user.articles).to.be.instanceOf(HasMany)
+        expect(user).to.haveOwnProperty('roles')
+        expect(user.roles).to.be.instanceOf(BelongsToMany)
+    }
+
+    @test
+    async hasOneSave() {
+        const user = await User.create(this.joe)
+
+        const profile = new Profile().fill({
+            address: 'address'
+        })
+        await user.profile.save(profile)
+
+        expect(user.profile.get()?.id).to.be.equal(profile.id)
+        expect(user.profile.get()?.user.get()?.id).to.be.equal(user.id)
+        expect(await Profile.first()).to.be.instanceOf(Profile)
+    }
+
+    @test
+    async hasOneLoad() {
+        const user = await User.create(this.joe)
+
+        const profile = new Profile().fill({
+            address: 'address'
+        })
+        await user.profile.save(profile)
+
+        const sameUser = await User.findOrFail(user.id)
+        expect(sameUser.profile).to.be.instanceOf(HasOne)
+        expect(sameUser.profile.get()).to.be.equal(undefined)
+        await sameUser.load('profile')
+
+        expect(sameUser.profile.get()?.id).to.be.equal(user.profile.get()?.id)
+        expect(sameUser.profile.get()?.address).to.be.equal('address')
+    }
+
+    @test
+    async hasOneEagerLoad() {
+        const user = await User.create(this.joe)
+
+        const profile = new Profile().fill({
+            address: 'address'
+        })
+        await user.profile.save(profile)
+
+        const sameUser = await User.with('profile').where('id', user.id).first() as User
+        expect(sameUser.profile.get()).to.deep.include({
+            id: profile.id,
+            address: 'address'
+        })
+    }
+
+    @test
+    async hasManySave() {
+        const user = await User.create(this.joe)
+
+        const article = new Article().fill({
+            title: 'title',
+            content: 'content',
+        })
+        await user.articles.save(article)
+
+        expect(user.articles).to.have.length(1)
+        expect(user.articles[0]).to.deep.include({
+            id: article.id,
+            title: 'title',
+            content: 'content',
+        })
+    }
+
+    @test
+    async hasManySaveUsingPlainObject() {
+        const user = await User.create(this.joe)
+
+        await user.articles.save({
+            title: 'title',
+            content: 'content',
+        } as Article)
+
+        expect(user.articles).to.have.length(1)
+        expect(user.articles[0]).to.deep.include({
+            title: 'title',
+            content: 'content',
+        })
+    }
+
+    @test
+    async hasManySaveUsingSaveOnUnsavedParent() {
+        const user = new User().fill(this.joe)
+
+        await user.articles.save(new Article().fill({
+            title: 'title',
+            content: 'content',
+        }))
+
+        expect(user.articles).to.have.length(1)
+        expect(user.articles[0]).to.deep.include({
+            title: 'title',
+            content: 'content',
+        })
+    }
+
+    @test
+    async hasManyLoad() {
+        const user = await User.create(this.joe)
+        await Article.create({
+            title: 'title',
+            content: 'content',
+            author: user
+        })
+
+        await user.load('articles')
+        expect(user.articles).to.be.instanceOf(HasMany)
+        expect(user.articles[0]).to.deep.include({
+            title: 'title',
+            content: 'content',
+        })
+    }
+
+    @test
+    async hasManyGet() {
+        const user = await User.create(this.joe)
+        const article = new Article().fill({
+            title: 'title',
+            content: 'content',
+        })
+        await user.articles.save(article)
+        await user.articles.load()
+        expect(user.articles[0]).to.deep.include({
+            title: 'title',
+            content: 'content',
+        })
+    }
+
+    @test
+    async hasManyEagerLoad() {
+        const user = new User().fill(this.joe)
+        const article = new Article().fill({
+            title: 'title',
+            content: 'content',
+        })
+        await user.articles.save(article)
+
+        const sameUser = await User.with('articles').where('id', user.id).first() as User
+        expect(sameUser.articles).to.have.length(1)
+        expect(user.articles[0]).to.deep.include({
+            id: article.id,
+            title: 'title',
+            content: 'content',
+        })
+    }
+
+    @test
+    async hasManyQuery() {
+        const user = await User.create(this.joe)
+        await user.articles.saveMany(
+            {
+                title: 'title',
+                content: 'joe\'s content',
+            },
+            {
+                title: 'other title',
+                content: 'other content',
+            },
+        )
+        const doe = await User.create(this.doe)
+        await doe.articles.save({
+            title: 'title',
+            content: 'doe\'s content',
+        })
+
+        const articles = await user.articles.where('title', 'title').get()
+        expect(articles).to.have.length(1)
+        expect(user.articles[0]).to.deep.include({
+            title: 'title',
+            content: 'joe\'s content',
+        })
+    }
+
+    @test
+    async belongsToSave() {
+        const user = await User.create(this.joe)
+        const article = new Article()
+        await user.articles.save(article)
+
+        expect(user.articles).to.have.length(1)
+        expect(user.articles[0].author).to.be.instanceof(BelongsTo)
+    }
+
+    @test
+    async belongsToEagerLoad() {
+        const user = await User.create(this.joe)
+        const article = new Article()
+        await user.articles.save(article)
+
+        const articles = await Article.with('author').get()
+
+        expect(articles).to.have.length(1)
+        expect(articles[0].author).to.be.instanceof(BelongsTo)
+    }
+
+    @test
+    async belongsToEagerLoadWithCustomQuery() {
+        const joe = await User.create(this.joe)
+        await joe.articles.save(Article.new({title: 'article1'}))
+        await joe.articles.save(Article.new({title: 'article2'}))
+
+        const user = await User.with(['articles', query => query.where('title', 'article1')]).first() as User
+
+        expect(user.articles).to.have.length(1)
+    }
+
+    // @test
+    // async deepBelongsToEagerLoadWithCustomQuery() {
+    //     const admin = await Role.create(this.admin)
+    //
+    //     const joe = await User.create(this.joe)
+    //     await joe.profile.save(new Profile({address: 'south address'}))
+    //     const doe = await User.create(this.doe)
+    //     await doe.profile.save(new Profile({address: 'east address'}))
+    //
+    //     await admin.users.add(joe, doe)
+    //
+    //     const role = await Role.with(['users.profile', query => query.whereLike('address', '%east%')]).first() as Role
+    //
+    //     expect(role.users).to.have.length(1)
+    //     expect(role.users[0].name).to.be.equal(doe.name)
+    // }
+
+    @test
+    async belongsToLoad() {
+        const user = await User.create(this.joe)
+        let article = new Article()
+        await user.articles.save(article)
+
+        article = await Article.findOrFail(article.id)
+        const a = await Article.get()
+        const u = await User.get()
+        await article.load('author')
+
+        expect(article.author).to.be.instanceOf(BelongsTo)
+        expect(article.author.get()).to.be.instanceOf(User)
+    }
+
+    @test
+    async belongsToReLoad() {
+        const user = await User.create(this.joe)
+        const article = new Article()
+        await user.articles.save(article)
+
+        await article.load('author')
+
+        expect(article.author).to.be.instanceOf(BelongsTo)
+        expect(article.author.get()).to.be.instanceOf(User)
+        expect(article.author.get()?.id).to.be.equal(user.id)
+    }
+
+    @test
+    async belongsToManySave() {
+        const user = new User().fill(this.joe)
+
+        const admin = await Role.create(this.admin)
+        const developer = await Role.create(this.developer)
+        await user.roles.add(admin.id, developer.id)
+
+        expect(user.roles).to.have.length(2)
+        expect(user.roles[0].id).to.be.equal(admin.id)
+        expect(user.roles[1].id).to.be.equal(developer.id)
+    }
+
+    @test
+    async belongsToManyEagerLoad() {
+        const user = await User.create(this.joe)
+
+        const admin = await Role.create(this.admin)
+        const developer = await Role.create(this.developer)
+        await user.roles.add(admin.id, developer.id)
+
+        const sameUser = await User.with('roles').where('id', user.id).first() as User
+
+        expect(sameUser.roles).to.have.length(2)
+        expect(sameUser.roles[0]).to.deep.include({
+            id: admin.id,
+            name: admin.name
+        })
+        expect(sameUser.roles[1]).to.deep.include({
+            id: developer.id,
+            name: developer.name
+        })
+    }
+
+    @test
+    async belongsToManyClearing() {
+        const user = new User().fill(this.joe)
+        const admin = await Role.create(this.admin)
+        const developer = await Role.create(this.developer)
+        await user.roles.add(admin.id, developer.id)
+
+        expect(user.roles).to.have.length(2)
+        await user.roles.clear()
+        expect(user.roles).to.have.length(0)
+    }
+
+    @test
+    async belongsToManyRemove() {
+        const user = new User().fill(this.joe)
+        const admin = await Role.create(this.admin)
+        const developer = await Role.create(this.developer)
+        await user.roles.add(admin.id, developer.id)
+
+        expect(user.roles).to.have.length(2)
+        await user.roles.remove(admin.id)
+        expect(user.roles).to.have.length(1)
+    }
+
+    @test
+    async belongsToManySync() {
+        const user = new User().fill(this.joe)
+        const admin = await Role.create(this.admin)
+        const developer = await Role.create(this.developer)
+        const manager = await Role.create({name: 'Manager'})
+        await user.roles.add(admin.id, manager.id)
+
+        await user.roles.sync(admin.id, developer)
+        expect(user.roles).to.have.length(2)
+        expect(user.roles[0]).to.have.property('id', admin.id)
+        expect(user.roles[1]).to.have.property('id', developer.id)
+    }
+
+    @test
+    async belongsToManySyncWithoutDetaching() {
+        const user = new User().fill(this.joe)
+        const admin = await Role.create(this.admin)
+        const developer = await Role.create(this.developer)
+        const manager = await Role.create({name: 'manager'})
+        await user.roles.add(admin.id, manager.id)
+
+        await user.roles.syncWithoutDetaching(admin.id, developer)
+        expect(user.roles).to.have.length(3)
+        expect(user.roles[0]).to.have.property('id', admin.id)
+        expect(user.roles[1]).to.have.property('id', manager.id)
+        expect(user.roles[2]).to.have.property('id', developer.id)
+    }
+
+    @test
+    async belongsToManyToggle() {
+        const user = new User().fill(this.joe)
+        const admin = await Role.create(this.admin)
+        await user.roles.add(admin.id)
+
+        expect(user.roles).to.have.length(1)
+        expect(user.roles[0]).to.have.property('id', admin.id)
+
+        const developer = await Role.create(this.developer)
+        await user.roles.toggle(admin.id, developer.id)
+
+        expect(user.roles).to.have.length(1)
+        expect(user.roles[0]).to.have.property('id', developer.id)
+    }
+
+    @test
+    async belongsToManyLoad() {
+        const user = new User().fill(this.joe)
+        const admin = await Role.create(this.admin)
+        await user.roles.add(admin.id)
+
+        const sameUser = await User.first() as User
+        await sameUser.load('roles')
+        expect(sameUser.roles[0]).to.deep.include(this.admin)
+    }
+
+    @test
+    async belongsToManyQuery() {
+        const user = new User().fill(this.joe)
+        const admin = await Role.create(this.admin)
+        const developer = await Role.create(this.developer)
+        await user.roles.add(admin.id, developer.id)
+
+        expect(user.roles).to.have.length(2)
+        const roles = await user.roles.where('name', developer.name).get()
+        expect(roles).to.have.length(1)
+        expect(roles[0]).to.deep.include(this.developer)
+    }
+
+    @test
+    async belongsToManyHas() {
+        const user = new User().fill(this.joe)
+        const admin = await Role.create(this.admin)
+        const developer = await Role.create(this.developer)
+        await user.roles.add(admin.id)
+
+        expect(await user.roles.has(admin)).to.be.equal(true)
+        expect(await user.roles.has(developer.id)).to.be.equal(false)
+    }
+
+    @test
+    async nestedEagerLoading() {
+        let user = await User.create(this.joe)
+        await user.articles.save(new Article())
+
+        user = await User.find(user.id) as User
+        await user.load('articles.author')
+
+        expect(user.articles[0].author.get()?.name).to.be.equal(user.name)
+    }
+
+    @test
+    async multipleNestedEagerLoading() {
+        let adminRole = await Role.create({name: 'Admin'})
+        const joe = await User.create(this.joe)
+        await adminRole.users.add(joe)
+        await joe.articles.save(new Article().fill({title: 'title'}))
+        await joe.profile.save(new Profile().fill({address: 'address'}))
+
+        adminRole = await Role.find(adminRole.id) as Role
+        await adminRole.load('users.articles.author', 'users.profile.user')
+
+        expect(adminRole.users[0].articles[0].title).to.be.equal('title')
+        expect(adminRole.users[0].profile.get()?.address).to.be.equal('address')
+        expect(adminRole.users[0].articles[0].author.get()?.name).to.be.equal(joe.name)
+        expect(adminRole.users[0].profile.get()?.user.get()?.name).to.be.equal(joe.name)
+    }
+}