@typetron/framework 0.5.6 → 0.5.7

package/Database/Drivers/MySQL/MysqlDriver.ts

@@ -1,123 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

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

package/Database/Drivers/SQLite/Create.ts

@@ -1,45 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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
-    }
-
-}