@typetron/framework 0.4.0-rc9 → 0.5.0-rc1

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)
+    }
+}

package/tests/Database/EntityTest.ts

@@ -0,0 +1,202 @@
+import { suite, test } from '@testdeck/mocha'
+import { expect } from 'chai'
+import { Connection, Entity, EntityConstructor, Query, SqliteDriver } from '../../Database'
+import { User } from './Entities/User'
+import { EntityQuery } from '../../Database/EntityQuery'
+import { Article } from './Entities/Article'
+import { Role } from './Entities/Role'
+
+@suite
+class EntityTest {
+    joe = {
+        id: 1,
+        name: 'Joe',
+        email: 'joe@example.com',
+    }
+
+    doe = {
+        id: 2,
+        name: 'Doe',
+        email: 'doe@example.com',
+    }
+
+    admin = {
+        id: 1,
+        name: 'Admin'
+    }
+    developer = {
+        id: 1,
+        name: 'Developer'
+    }
+
+    data = {
+        users: [this.joe, this.doe],
+        roles: [this.admin, this.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, Article, Role].pluck('metadata'))
+    }
+
+    async after() {
+        for await (const entity of [User, Article, Role]) {
+            await (entity as EntityConstructor<Entity>).truncate()
+        }
+    }
+
+    expectToContain(actual: User, expected: {[key: string]: string | number | Date}) {
+        const keys = Object.keys(expected)
+        keys.forEach(key => {
+            expect(actual).to.have.property(key, expected[key])
+        })
+    }
+
+    @test
+    fillEntityWhenInstantiating() {
+        expect(new User().fill({name: 'Joe'})).to.deep.include({name: 'Joe'})
+    }
+
+    @test
+    getEntityTable() {
+        expect(User.getTable()).to.equal('users')
+        expect((new User()).getTable()).to.equal('users')
+    }
+
+    @test
+    async createsNewQuery() {
+        expect(User.newQuery()).to.be.an.instanceof(EntityQuery)
+        const user = new User()
+        expect(user.newQuery()).to.be.an.instanceof(EntityQuery)
+    }
+
+    @test
+    async getEveryRecord() {
+        await Query.table(User.getTable()).insert([this.joe, this.doe])
+
+        const users = await User.get()
+
+        expect(users).to.have.length(2)
+
+        users.forEach((user, index) => this.expectToContain(user, this.data.users[index]))
+    }
+
+    // @test
+    // async where() {
+    //     const modelMock = mock(User);
+    //     const user = instance(modelMock);
+    //
+    //     const queryMock = mock(EntityQuery);
+    //     verify(queryMock.where('name', 'Joe')).once();
+    //     when(user.newQuery()).thenReturn(instance(queryMock));
+    //
+    //     const users = await User.where('name', 'Joe').get();
+    //
+    //     users.forEach((user, index) => this.expectToContain(user, this.data.users[index]));
+    // }
+    //
+    // @test
+    // async whereIn() {
+    //     when(this.connection.get(anyOfClass(Query))).thenResolve(this.data.users);
+    //
+    //     const users = await User.whereIn('name', ['Joe', 'Doe']).get();
+    //
+    //     users.forEach((user, index) => this.expectToContain(user, this.data.users[index]));
+    // }
+    //
+    @test
+    async save() {
+        const data = {email: 'tester', name: 'Tester'}
+        const user = new User().fill(data)
+
+        this.expectToContain(user, data)
+        expect(user.id).to.be.equal(undefined)
+        await user.save()
+        expect(user.id).to.be.equal(1)
+        expect(user.createdAt).to.be.an.instanceOf(Date)
+        expect(user.updatedAt).to.be.an.instanceOf(Date)
+    }
+
+    @test
+    async insertMany() {
+        await User.insert([this.joe, this.doe])
+
+        const users = await User.get()
+        expect(users).to.have.length(2)
+        this.expectToContain(users[0], this.joe)
+        this.expectToContain(users[1], this.doe)
+    }
+
+    // @test
+    // async test0() {
+    // const users = await User.get();
+    // const users = await User.get('id', 'name');
+    // const user = await User.first('id');
+    // const user = await User.firstOrNew({name: 'John'}, {email: 'john@example.com'});
+    // const user = await User.firstOrCreate({name: 'John'}, {email: 'john@example.com'});
+    // const user = await User.find(1);
+    // const users = await User.with('articles').get();
+    // }
+
+    @test
+    async getSpecificColumns() {
+        await Query.table(User.getTable()).insert([this.joe])
+
+        const users = await User.get('id', 'name')
+
+        expect(users).to.have.length(1)
+        expect(users.first()).to.have.property('name', this.joe.name)
+        expect(users.first()).and.to.have.property('id', this.joe.id)
+
+        // TODO with the new JS updates, the Entity properties are initialized to undefined,
+        //  which means we will always get them in the object and this assert below will fail
+        // But, the actual problem is picking what columns to select.
+        // User.get(col1, col2) will return an User instance with col1 and col2 values but undefined for other columns
+        // This should be invalid because there might be col3 which might be non-optional and should always have a value
+        // expect(users.first()).and.to.not.have.property('email')
+    }
+
+    @test
+    async getFirstRecord() {
+        await Query.table(User.getTable()).insert([this.joe, this.doe])
+
+        const user = await User.first() as User
+
+        this.expectToContain(user, this.joe)
+    }
+
+    @test
+    async getFirstRecordWithSpecificColumns() {
+        await Query.table(User.getTable()).insert([this.joe])
+
+        const user = await User.first('id') as User
+
+        expect(user).to.have.property('id', this.joe.id)
+
+        // TODO this has the same issue as the test `getSpecificColumns`
+        // expect(user).to.not.have.property('name')
+    }
+
+    @test
+    async getFirstRecordOrInstantiateOneIfNot() {
+        const john = await User.firstOrNew({name: 'John'}, {email: 'john@example.com'})
+
+        expect(john).to.have.property('name', 'John')
+        expect(john).to.have.property('email', 'john@example.com')
+        expect(john.id).to.be.undefined
+        expect(await User.get()).to.have.length(0)
+    }
+
+    @test
+    async getFirstRecordOrCreateOneIfNot() {
+        const john = await User.firstOrCreate({name: 'John'}, {email: 'john@example.com'})
+
+        expect(john).to.have.property('name', 'John')
+        expect(john).to.have.property('email', 'john@example.com')
+        expect(john).to.have.property('id')
+        expect(await User.get()).to.have.length(1)
+    }
+}