@typetron/framework 0.4.0-rc8 → 0.5.0-rc1

package/tests/Database/Drivers/MySQL/AlterTest.ts

@@ -0,0 +1,100 @@
+import { suite, test } from '@testdeck/mocha'
+import { expectQuery } from '@Typetron/tests/Database/utils'
+import { AddColumn, AddConstraint, Alter, Constraints, DropColumn, ModifyColumn } from '@Typetron/Database/Drivers/MySQL/Alter'
+
+@suite
+class AlterTest {
+
+    @test
+    async addColumn() {
+        const addAge = new AddColumn({
+            name: 'age',
+            type: 'integer',
+        })
+        const statement = new Alter('test', [addAge])
+        expectQuery(statement).toEqual('ALTER TABLE test ADD age integer')
+    }
+
+    @test
+    async addPrimaryKeyColumn() {
+        const addAge = new AddColumn({
+            name: 'age',
+            type: 'integer',
+        })
+        const statement = new Alter('test', [addAge])
+        expectQuery(statement).toEqual('ALTER TABLE test ADD age integer')
+    }
+
+    @test
+    async dropColumn() {
+        const age = new DropColumn('age')
+        const statement = new Alter('test', [age])
+        expectQuery(statement).toEqual('ALTER TABLE test DROP COLUMN age')
+    }
+
+    @test
+    async ModifyColumn() {
+        const age = new ModifyColumn({
+            name: 'age',
+            type: 'integer',
+        })
+        const statement = new Alter('test', [age])
+        expectQuery(statement).toEqual('ALTER TABLE test MODIFY age integer')
+    }
+
+    @test
+    async ModifyColumnWithAutoIncrement() {
+        const age = new ModifyColumn({
+            name: 'age',
+            type: 'integer',
+            autoIncrement: 1
+        })
+        const statement = new Alter('test', [age])
+        expectQuery(statement).toEqual('ALTER TABLE test MODIFY age integer AUTO_INCREMENT')
+    }
+
+    @test
+    async addPrimaryKeyConstraint() {
+        const age = new AddConstraint({
+            name: 'age',
+            type: 'integer',
+        }, Constraints.PrimaryKey)
+        const statement = new Alter('test', [age])
+        expectQuery(statement).toEqual('ALTER TABLE test ADD CONSTRAINT PRIMARY KEY (age)')
+    }
+
+    @test
+    async addForeignKeyConstraint() {
+        const age = new AddConstraint({
+            name: 'age',
+            type: 'integer',
+        }, Constraints.ForeignKey)
+        const statement = new Alter('test', [age])
+        expectQuery(statement).toEqual('ALTER TABLE test ADD CONSTRAINT FOREIGN KEY (age)')
+    }
+
+    @test
+    async altersMultipleColumns() {
+        const addAge = new AddColumn({
+            name: 'age',
+            type: 'integer',
+        })
+        const dropName = new DropColumn('age')
+        const dropTitle = new DropColumn('title')
+
+        const addAddress = new AddColumn({
+            name: 'address',
+            type: 'varchar(255)',
+        })
+        const statement = new Alter('test', [addAge, dropName, dropTitle, addAddress])
+        expectQuery(statement).toEqual(`
+            ALTER TABLE test
+                ADD age integer,
+            DROP
+            COLUMN age,
+                DROP
+            COLUMN title,
+                ADD address varchar(255)
+        `)
+    }
+}

package/tests/Database/Drivers/MySQL/CreateTest.ts

@@ -0,0 +1,39 @@
+import { suite, test } from '@testdeck/mocha'
+import { Create } from '@Typetron/Database/Drivers/MySQL/Create'
+import { expectQuery } from '@Typetron/tests/Database/utils'
+
+@suite
+class CreateTest {
+
+    @test
+    async createsEmptyTable() {
+        const statement = new Create('test')
+        expectQuery(statement).toEqual('CREATE TABLE test ( )')
+    }
+
+    @test
+    async createsTableWithIntegerColumn() {
+        const statement = new Create('test', [{
+            name: 'age',
+            type: 'integer',
+        }])
+        expectQuery(statement).toEqual('CREATE TABLE test ( age integer )')
+    }
+
+    @test
+    async createsTableWithPrimaryAutoIncrementColumn() {
+        const statement = new Create('test', [{
+            name: 'id',
+            type: 'integer',
+            primaryKey: true,
+            autoIncrement: 1
+        }])
+        expectQuery(statement).toEqual(`
+            CREATE TABLE test
+            (
+                id integer AUTO_INCREMENT,
+                PRIMARY KEY (id)
+            )
+        `)
+    }
+}

package/tests/Database/Drivers/MysqlDriverTest.ts

@@ -0,0 +1,140 @@
+import { suite, test } from '@testdeck/mocha'
+import { BelongsTo, Column, Entity, HasOne, ID, MysqlDriver, Options, PrimaryColumn, Relation } from '@Typetron/Database'
+import { anyString, instance, mock, when } from 'ts-mockito'
+import { Schema } from '@Typetron/Database/Drivers/MySQL/Schema'
+import { expectQuery } from '../utils'
+import { DatabaseDriver } from '@Typetron/Database/Drivers/DatabaseDriver'
+
+@suite
+class MysqlDriverTest {
+
+    driver: DatabaseDriver
+    schema: Schema
+    query: string
+
+    async before() {
+        this.driver = mock(MysqlDriver)
+        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 AUTO_INCREMENT,
+                PRIMARY KEY (id)
+            )
+        `)
+    }
+
+    @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'
+            },
+        ]))
+
+        class User extends Entity {
+            @Column()
+            column1: number
+
+            @Column()
+            column2: string
+        }
+
+        await this.schema.synchronize([User].pluck('metadata'))
+
+        expectQuery(this.query).toEqual(`
+            ALTER TABLE user
+                ADD column1 integer,
+            MODIFY column2 varchar(255),
+            DROP
+            COLUMN column3
+        `)
+    }
+
+    @test
+    async altersTableAddPrimaryKey() {
+        when(this.driver.tableExists(anyString())).thenReturn(Promise.resolve(true))
+        when(this.driver.tableColumns(anyString())).thenReturn(Promise.resolve([]))
+
+        class User extends Entity {
+            @PrimaryColumn()
+            id: ID
+        }
+
+        const queries: string[] = []
+        when(this.driver.run(anyString())).thenCall((query: string) => queries.push(query))
+
+        await this.schema.synchronize([User].pluck('metadata'))
+
+        expectQuery(queries[0]).toEqual(`
+            ALTER TABLE user
+                ADD id integer
+        `)
+
+        expectQuery(queries[1]).toEqual(`
+            ALTER TABLE user
+                ADD CONSTRAINT PRIMARY KEY (id),
+                MODIFY id integer AUTO_INCREMENT
+        `)
+    }
+}

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