@typetron/framework 0.5.3 → 0.5.4

package/Database/Drivers/MySQL/MysqlDriver.ts

@@ -0,0 +1,123 @@
+import { DatabaseDriver } from '../DatabaseDriver'
+import { Connection, ConnectionConfig, createConnection, OkPacket } from 'mysql'
+import { SqlValue } from '../../Types'
+import { Create } from './Create'
+import { Select } from '../SQL/Statements/Select'
+import { Insert } from '../SQL/Statements/Insert'
+import { Delete } from '../SQL/Statements/Delete'
+import { Update } from '../SQL/Statements/Update'
+import { Alter } from '../SQL/Statements/Alter'
+import { SchemaContract } from '../SchemaContract'
+import { Schema } from './Schema'
+
+interface ColumnInfo {
+    name: string
+    type: string
+    nullable: 0 | 1
+    default?: string | number
+    autoIncrement: 0 | 1
+    primaryKey: 0 | 1
+}
+
+export class MysqlDriver extends DatabaseDriver {
+    connection: Connection
+
+    schema: SchemaContract = new Schema(this)
+
+    statements = {
+        create: Create,
+        select: Select,
+        insert: Insert,
+        delete: Delete,
+        update: Update,
+        alter: Alter,
+    }
+
+    constructor(connectionConfig: ConnectionConfig) {
+        super()
+        this.connection = createConnection({
+            connectTimeout: 30000,
+            ...connectionConfig,
+        })
+
+        this.connection.connect()
+    }
+
+    async truncate(table: string) {
+        await this.run(`TRUNCATE TABLE ${table}`)
+    }
+
+    runRaw<T>(query: string, params: SqlValue[] = []): Promise<T | OkPacket> {
+        return new Promise((resolve, reject) => {
+            this.connection.query(query, params, (error, results, fields) => {
+                if (error) {
+                    error.message += `in SQL: "${error.sql}"`
+                    return reject(error)
+                }
+                resolve(results)
+            })
+        })
+    }
+
+    async run(query: string, params: SqlValue[] = []) {
+        await this.runRaw(query, params)
+    }
+
+    async get<T>(query: string, params: SqlValue[] = []): Promise<T[]> {
+        return (await this.runRaw(query, params) as T[])
+    }
+
+    async first<T>(query: string, params: SqlValue[] = []): Promise<T> {
+        return (await this.runRaw(query, params) as T[])?.[0]
+    }
+
+    async insertOne(query: string, params: SqlValue[] = []): Promise<number> {
+        return (await this.runRaw(query, params) as OkPacket).insertId
+    }
+
+    tables() {
+        return this.get<{name: string}>(
+            `select TABLE_NAME as name
+             from information_schema.TABLES
+             WHERE table_schema = ?
+            `,
+            [this.connection.config.database]
+        )
+    }
+
+    tableExists(table: string): Promise<boolean> {
+        return this.first(
+            `select *
+             from information_schema.tables
+             where table_name = ?
+               and table_schema = ?
+            `,
+            [table, this.connection.config.database]
+        )
+    }
+
+    async tableColumns(table: string) {
+        const columnsInfo = await this.get<ColumnInfo>(
+            `select cast(IS_NULLABLE = 'YES' as unsigned)      as nullable,
+                    cast(EXTRA = 'auto_increment' as unsigned) as autoIncrement,
+                    cast(COLUMN_KEY = 'PRI' as unsigned)       as primaryKey,
+                    COLUMN_NAME                                as name,
+                    DATA_TYPE                                  as type,
+                    COLUMN_DEFAULT as 'default'
+             from information_schema.COLUMNS
+             where table_name = ?
+               and table_schema = ?
+            `,
+            [table, this.connection.config.database]
+        )
+
+        return columnsInfo.map(info => ({
+            name: info.name,
+            type: info.type,
+            nullable: Boolean(info.nullable),
+            default: info.default,
+            autoIncrement: info.autoIncrement,
+            primaryKey: Boolean(info.primaryKey)
+        }))
+    }
+}

package/Database/Drivers/MySQL/Schema.ts

@@ -0,0 +1,82 @@
+import { ColumnField, Entity, Expression, PrimaryField } from '../..'
+import { Schema as BaseSchema } from '../SQL/Schema'
+import { Create } from './Create'
+import { typesMatches } from '.'
+import { ColumnDefinitionOptions } from '../SQL'
+import { AddColumn, AddConstraint, Alter, Constraints, DropColumn, ModifyColumn } from './Alter'
+
+export class Schema extends BaseSchema {
+
+    columnMetadataToColumnDefinition(metadata: ColumnField<Entity>) {
+        return {
+            name: metadata.column,
+            primaryKey: metadata.constructor === PrimaryField,
+            autoIncrement: Number(metadata.constructor === PrimaryField),
+            type: this.getColumnTypeBasedOnTypescriptType(metadata),
+            default: undefined,
+            nullable: true
+        }
+    }
+
+    async create(table: string, columns: ColumnField<Entity>[]) {
+        const columnsDefinitions: ColumnDefinitionOptions[] = columns.map(column => this.columnMetadataToColumnDefinition(column))
+        const createStatement = new Create(table, columnsDefinitions)
+
+        await this.driver.run(createStatement.toSQL())
+    }
+
+    protected async syncTableColumns(table: string, columnsMetadata: ColumnField<Entity>[]) {
+        const columns = columnsMetadata.map(metadata => this.columnMetadataToColumnDefinition(metadata))
+
+        const tableColumns = await this.driver.tableColumns(table)
+
+        let alters: Expression[] = []
+
+        alters = alters.concat(
+            columns
+                .whereNotIn('name', tableColumns.pluck('name'))
+                .map(column => new AddColumn({...column, autoIncrement: undefined}))
+        )
+
+        columns.whereIn('name', tableColumns.pluck('name'))
+            .forEach(column => {
+                const typeInDB = tableColumns.findWhere('name', column.name)?.type
+                if (typeInDB !== column.type) {
+                    alters.push(new ModifyColumn(column))
+                }
+            })
+
+        alters = alters.concat(
+            tableColumns
+                .whereNotIn('name', columns.pluck('name'))
+                .map(tableColumn => new DropColumn(tableColumn.name))
+        )
+
+        await this.driver.run(new Alter(table, alters).toSQL())
+
+        const additionalAlters: Expression[] = []
+        columns.forEach(column => {
+            const dbInfo = tableColumns.findWhere('name', column.name)
+            if (column.primaryKey && !dbInfo?.primaryKey) {
+                additionalAlters.push(new AddConstraint(column, Constraints.PrimaryKey))
+            }
+            if (column.autoIncrement && !dbInfo?.autoIncrement) {
+                additionalAlters.push(new ModifyColumn(column))
+            }
+        })
+
+        if (!additionalAlters.empty()) {
+            await this.driver.run(new Alter(table, additionalAlters).toSQL())
+        }
+    }
+
+    private getColumnTypeBasedOnTypescriptType(column: ColumnField<Entity>) {
+        const typePrototype = Array.from(typesMatches.keys())
+            .find(key => column.type().prototype instanceof key) || String
+
+        return typesMatches.get(column.type())
+            ?? typesMatches.get(column.constructor)
+            ?? typesMatches.get(typePrototype)
+            ?? typesMatches.get(String) as string
+    }
+}

package/Database/Drivers/MySQL/index.ts

@@ -0,0 +1,13 @@
+import { Entity } from '../../Entity'
+import { JSONField, PrimaryField } from '../../Fields'
+
+// tslint:disable-next-line:no-any
+export const typesMatches = new Map<any, string>([
+    [Entity, 'integer'],
+    [PrimaryField, `integer`],
+    [Number, 'integer'],
+    [String, 'varchar(255)'],
+    [Date, 'datetime'],
+    [JSONField, 'text'],
+    [Boolean, 'integer'],
+])

package/Database/Drivers/SQL/Schema.ts

@@ -0,0 +1,73 @@
+import { SchemaContract } from '../SchemaContract'
+import { BelongsToManyField, ColumnField, Entity, EntityConstructor, EntityMetadata } from '../..'
+
+export abstract class Schema extends SchemaContract {
+
+    // async create(table: string, columns: ColumnField<Entity>[]) {
+    //     const columnsSQLs = columns
+    //         .filter(column => column.column)
+    //         .map(columnMetadata => this.getColumnSql(columnMetadata))
+    //
+    //     // @ts-ignore
+    //     const createStatement = new Create({
+    //         table,
+    //         columns: columnsSQLs
+    //     })
+    //
+    //     await this.driver.run(createStatement.toSql())
+    // }
+
+    // async addColumn(table: string, column: ColumnField<Entity>) {
+    //     await this.driver.run(`ALTER TABLE ${table}
+    //         ADD ${this.getColumnSql(column)}(6)`)
+    // }
+
+    async synchronize(entitiesMetadata: EntityMetadata<Entity, Entity>[]) {
+        const pivotTables = new Map<string, ColumnField<Entity>[]>()
+        for await(const metadata of entitiesMetadata) {
+            const table = metadata.table as string
+            const belongsToManyFields = Object.values(metadata.inverseRelationships)
+                .filter(field => field instanceof BelongsToManyField) as BelongsToManyField<Entity, Entity>[]
+
+            belongsToManyFields.forEach(field => {
+                const entity = Entity as EntityConstructor<Entity>
+                const pivotTableColumns: ColumnField<Entity>[] = [
+                    // new ColumnField(entity, 'id', () => PrimaryField, 'id'),
+                    ...[field.getParentForeignKey(), field.getRelatedForeignKey()].sort().map(columnName => {
+                        return new ColumnField(entity, columnName, () => Number, columnName)
+                    })
+                ]
+                pivotTables.set(field.getPivotTable(), pivotTableColumns)
+            })
+            const tableInfo = await this.driver.tableExists(table)
+            if (!tableInfo) {
+                await this.create(table, Object.values({...metadata.columns, ...metadata.relationships}))
+                continue
+            }
+            await this.syncTableColumns(table, Object.values({...metadata.columns, ...metadata.relationships}))
+        }
+
+        for await (const [name, columns] of pivotTables) {
+            const tableInfo = await this.driver.tableExists(name)
+            if (!tableInfo) {
+                await this.create(name, columns)
+                continue
+            }
+            await this.syncTableColumns(name, columns)
+        }
+    }
+
+    protected abstract syncTableColumns(table: string, columns: ColumnField<Entity>[]): Promise<void>;
+
+    // protected getColumnSql(columnMetadata: ColumnField<Entity>): string {
+    //     const columnType = columnMetadata.type()
+    //     const type = Array.from(this.typesMatches.keys())
+    //         .find(key =>
+    //             key === columnMetadata.type() || columnType.prototype instanceof key || columnMetadata instanceof key
+    //         ) || String
+    //
+    //     const columnInfo = this.typesMatches.get(type)
+    //
+    //     return `${columnMetadata.column} ${columnInfo}`
+    // }
+}

package/Database/Drivers/SQL/Statements/Alter.ts

@@ -0,0 +1,22 @@
+import { BaseStatement } from './BaseStatement'
+import { ColumnField, Entity } from '../../..'
+
+export class Alter extends BaseStatement {
+
+    columns: ColumnField<Entity>[] = []
+
+    getColumns() {
+        return ''
+    }
+
+    toSQL() {
+        return `
+            ALTER
+                TABLE
+                ${this.table}
+                (
+                ${this.getColumns()}
+                )
+        `
+    }
+}

package/Database/Drivers/SQL/Statements/BaseStatement.ts

@@ -0,0 +1,55 @@
+import { wrap } from '../../../Helpers'
+import { Statement } from '../../Statement'
+
+export abstract class BaseStatement extends Statement {
+
+    get table() {
+        return wrap(this.components.table || '')
+    }
+
+    get wheres() {
+        const wheres = this.components.wheres || []
+
+        return wheres.map(where => {
+            this.bindings = this.bindings.concat(where.getValues())
+            return where.toSql()
+        }).join(' ').replace(/^(and |or )/i, '')
+    }
+
+    get limit() {
+        const limit = this.components.limit
+        return limit ? `LIMIT ${limit.from}` + (limit.count ? `, ${limit.count}` : '') : ''
+    }
+
+    get joins() {
+        return this.components.joins.map(join => {
+            return `${join.type} JOIN ${wrap(join.table)} ON ${join.first} ${join.operator} ${join.second}`
+        }).join(' ')
+    }
+
+    get groups() {
+        if (!this.components.groups.length) {
+            return ''
+        }
+
+        return `GROUP BY ` + this.components.groups.map(column => wrap(column)).join(', ')
+    }
+
+    get having() {
+        return ''
+    }
+
+    get orders() {
+        if (!this.components.orders?.length) {
+            return ''
+        }
+
+        return 'ORDER BY ' + this.components.orders.map(order => `${wrap(order[0])} ${order[1]}`).join(', ')
+    }
+
+    abstract toSQL(): string;
+
+    toString() {
+        return this.toSQL()
+    }
+}

package/Database/Drivers/SQL/Statements/Delete.ts

@@ -0,0 +1,20 @@
+import { BaseStatement } from './BaseStatement'
+
+export class Delete extends BaseStatement {
+
+    get wheres() {
+        if (!this.components.wheres.length) {
+            return ''
+        }
+
+        return `WHERE ` + super.wheres
+    }
+
+    toSQL() {
+        return `
+            DELETE
+            FROM ${this.table} ${this.wheres} ${this.orders} ${this.limit}
+        `
+    }
+
+}

package/Database/Drivers/SQL/Statements/Insert.ts

@@ -0,0 +1,24 @@
+import { BaseStatement } from './BaseStatement'
+import { wrap } from '../../../Helpers'
+
+export class Insert extends BaseStatement {
+
+    get columns() {
+        const values = this.components.insert || []
+
+        return wrap(Object.keys(values.first() ?? {}))
+    }
+
+    get values() {
+        return (this.components.insert || []).map(valuesMap => {
+            const values = Object.values(valuesMap)
+            this.bindings = this.bindings.concat(values)
+            return '(' + [...Array(values.length)].map(() => '?').join(', ') + ')'
+        }).join(', ')
+    }
+
+    toSQL() {
+        return `INSERT INTO ${this.table} (${this.columns})
+                VALUES ${this.values} `
+    }
+}

package/Database/Drivers/SQL/Statements/Select.ts

@@ -0,0 +1,55 @@
+import { BaseStatement } from './BaseStatement'
+import { StringExpression } from '../../..'
+import { wrap } from '../../../Helpers'
+
+export class Select extends BaseStatement {
+    get distinct() {
+        return this.components.distinct ? 'DISTINCT ' : ''
+    }
+
+    get columns() {
+        let columns = this.components.columns || []
+        columns = columns.map(column => {
+            return column instanceof StringExpression ? column.value : wrap(column)
+        })
+
+        const aggregate = this.components.aggregate
+        if (aggregate) {
+            columns.push(`${aggregate.function}(${wrap(aggregate.columns) || '*'}) as aggregate`)
+        }
+
+        if (!columns.length) {
+            return '*'
+        }
+
+        return columns.join(', ')
+    }
+
+    get wheres() {
+        if (!this.components.wheres.length) {
+            return ''
+        }
+
+        return `WHERE ${super.wheres}`
+    }
+
+    toSQL() {
+        return `
+            SELECT ${this.distinct}${this.columns}
+            FROM ${this.table} ${this.joins} ${this.wheres} ${this.groups}
+                ${this.having}
+                ${this.orders}
+                ${this.limit}
+        `
+    }
+}
+
+/*
+const query = `SELECT *
+		   FROM users
+		   where name = 'john'                  --  where basic
+			  or (age in (1, 2, 3) and age > 2) -- where nested
+			  or age in (1, 2, 3)               -- where in
+			  or age in (SELECT age from users) -- where subSelect
+`;
+*/

package/Database/Drivers/SQL/Statements/Update.ts

@@ -0,0 +1,33 @@
+import { BaseStatement } from './BaseStatement'
+
+export class Update extends BaseStatement {
+
+    get wheres() {
+        if (!this.components.wheres.length) {
+            return ''
+        }
+
+        return 'WHERE ' + super.wheres
+    }
+
+    get columns() {
+        const columns = []
+        const values = this.components.update || {}
+        for (const column in values) {
+            if (values.hasOwnProperty(column)) {
+                this.bindings.push(values[column])
+                columns.push(`${column} = ?`)
+            }
+        }
+        return columns.join(', ')
+    }
+
+    toSQL() {
+        return `
+            UPDATE
+                ${this.table}
+            SET ${this.columns}
+                    ${this.wheres} ${this.orders} ${this.limit}
+        `
+    }
+}

package/Database/Drivers/SQL/index.ts

@@ -0,0 +1,8 @@
+export interface ColumnDefinitionOptions {
+    name: string
+    type: string
+    nullable?: boolean
+    default?: string | number
+    autoIncrement?: number
+    primaryKey?: boolean
+}

package/Database/Drivers/SQLite/Create.ts

@@ -0,0 +1,45 @@
+import { BaseStatement } from '../SQL/Statements/BaseStatement'
+import { ColumnDefinitionOptions } from '../SQL'
+
+export class Create extends BaseStatement {
+
+    constructor(table: string, public columns: ColumnDefinitionOptions[] = []) {
+        super({
+            table,
+            columns: [],
+            joins: [],
+            wheres: [],
+            groups: [],
+            orders: [],
+            having: []
+        })
+    }
+
+    toSQL() {
+        const definitions: string[] = this.getColumnsSQL(this.columns)
+
+        return `
+            CREATE TABLE ${this.table}
+            (
+                ${definitions.join(', \n')}
+            )
+        `
+    }
+
+    private getColumnsSQL(columns: ColumnDefinitionOptions[]) {
+        return columns.map(this.getColumnSQL)
+    }
+
+    private getColumnSQL(column: ColumnDefinitionOptions) {
+        const sqlParts = [column.name, column.type]
+
+        if (column.primaryKey) {
+            sqlParts.push('PRIMARY KEY')
+        }
+        if (column.autoIncrement) {
+            sqlParts.push('AUTOINCREMENT')
+        }
+
+        return sqlParts.join(' ')
+    }
+}

package/Database/Drivers/SQLite/Schema.ts

@@ -0,0 +1,54 @@
+import { ColumnField, Entity, PrimaryField } from '../..'
+import { Schema as BaseSchema } from '../SQL/Schema'
+import { Create } from './Create'
+import { typesMatches } from '.'
+import { ColumnDefinitionOptions } from '../SQL'
+import { wrap } from '../../Helpers'
+
+export class Schema extends BaseSchema {
+
+    columnMetadataToColumnDefinition(metadata: ColumnField<Entity>) {
+        return {
+            name: metadata.column,
+            primaryKey: metadata.constructor === PrimaryField,
+            autoIncrement: Number(metadata.constructor === PrimaryField),
+            type: this.getColumnTypeBasedOnTypescriptType(metadata),
+            default: undefined,
+            nullable: true
+        }
+    }
+
+    async create(table: string, columns: ColumnField<Entity>[]) {
+        const columnsDefinitions: ColumnDefinitionOptions[] = columns.map(column => this.columnMetadataToColumnDefinition(column))
+        const createStatement = new Create(table, columnsDefinitions)
+
+        await this.driver.run(createStatement.toSQL())
+    }
+
+    protected async syncTableColumns(table: string, columnsMetadata: ColumnField<Entity>[]) {
+        const columns = columnsMetadata.map(metadata => this.columnMetadataToColumnDefinition(metadata))
+        const tableColumns = await this.driver.tableColumns(table)
+
+        if (tableColumns.length) {
+            const temporaryTableName = table + '_alter_tmp'
+            await this.create(temporaryTableName, columnsMetadata)
+            const columnList = wrap(columns.whereIn('name', tableColumns.pluck('name')).pluck('name'))
+            await this.driver.run(`INSERT INTO ${temporaryTableName}(${columnList})
+                                   SELECT ${columnList}
+                                   FROM ${table}`)
+            await this.driver.run(`DROP TABLE ${table}`)
+            await this.driver.run(`ALTER TABLE ${temporaryTableName} RENAME TO ${table}`)
+        }
+    }
+
+    private getColumnTypeBasedOnTypescriptType(column: ColumnField<Entity>) {
+        const typePrototype = Array.from(typesMatches.keys())
+            .find(key => column.type().prototype instanceof key) || String
+
+        return typesMatches.get(column.type())
+            ?? typesMatches.get(column.constructor)
+            ?? typesMatches.get(typePrototype)
+            ?? typesMatches.get(String) as string
+    }
+
+}