@typetron/framework 0.5.21 → 0.5.22

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

package/Database/Drivers/SQLite/SqliteDriver.ts

@@ -0,0 +1,144 @@
+import { Database } from 'sqlite3'
+import { SqlValue } from '../../Types'
+import { DatabaseDriver } from '../DatabaseDriver'
+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 { Schema } from './Schema'
+import { SchemaContract } from '../SchemaContract'
+import { wrap } from '../../Helpers'
+import { Create } from './Create'
+
+interface ColumnInfo {
+    name: string
+    type: string
+    notnull: string
+    dflt_value: string
+    pk: string
+}
+
+export class SqliteDriver implements DatabaseDriver {
+    database: Database
+
+    schema: SchemaContract = new Schema(this)
+
+    statements = {
+        create: Create,
+        select: Select,
+        insert: Insert,
+        delete: Delete,
+        update: Update,
+        alter: Alter,
+    }
+
+    constructor(databaseFilePath: string) {
+        this.database = new Database(databaseFilePath)
+    }
+
+    async run(query: string, params: SqlValue[] = []): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const appError = new Error()
+            this.database.run(query, params, (error) => {
+                if (error) {
+                    return reject(this.buildError(appError, error, query))
+                }
+
+                resolve()
+            })
+        })
+    }
+
+    async insertOne(query: string, params: SqlValue[] = []): Promise<number> {
+        await this.run(query, params)
+        return this.lastInsertedId()
+    }
+
+    async truncate(table: string) {
+        await this.run(`DELETE
+                        FROM ${table}`)
+        return this.run(`DELETE
+                         FROM SQLITE_SEQUENCE
+                         WHERE name = '${table}'`)
+    }
+
+    async lastInsertedId(): Promise<number> {
+        return new Promise<number>((resolve, reject) => {
+            const appError = new Error()
+            const query = 'SELECT last_insert_rowid() as id;'
+            this.database.get(query, [], (error, lastInsert: any) => {
+                if (error) {
+                    return reject(this.buildError(appError, error, query))
+                }
+                resolve(lastInsert.id)
+            })
+        })
+    }
+
+    async get<T>(query: string, params: SqlValue[] = []): Promise<T[]> {
+        return new Promise<T[]>((resolve, reject) => {
+            const appError = new Error()
+            this.database.all(query, params, (error, rows: any) => {
+                if (error) {
+                    return reject(this.buildError(appError, error, query))
+                }
+                resolve(rows)
+            })
+        })
+    }
+
+    async first<T>(query: string, params: SqlValue[] = []): Promise<T> {
+        return new Promise<T>((resolve, reject) => {
+            const appError = new Error()
+            this.database.get(query, params, (error, row: any) => {
+                if (error) {
+                    return reject(this.buildError(appError, error, query))
+                }
+                resolve(row)
+            })
+        })
+    }
+
+    buildError(appError: Error, databaseError: Error, query?: string) {
+        appError.message = `${databaseError} in '${query}' `
+        // appError.stack = appError.stack?.replace('Error:', `${appError.message}`)
+        return appError
+    }
+
+    tables() {
+        return this.get<{name: string}>(
+            `SELECT name
+             FROM sqlite_master
+             WHERE type = 'table'`
+        )
+    }
+
+    tableExists(table: string): Promise<boolean> {
+        return this.first(
+            `SELECT *
+             FROM sqlite_master
+             WHERE name = ?`,
+            [table]
+        )
+    }
+
+    async tableColumns(table: string) {
+        const columnsInfo = await this.get<ColumnInfo>(
+            `PRAGMA table_info(${wrap(table)})`
+        )
+        const autoIncrements = await this.get<{name: string; seq: number}>(`
+            SELECT *
+            FROM sqlite_sequence
+        `)
+
+        return columnsInfo.map((info) => ({
+            name: info.name,
+            type: info.type,
+            nullable: !info.notnull,
+            default: info.dflt_value,
+            autoIncrement: Number(Boolean(autoIncrements.findWhere('name', table))),
+            primaryKey: Boolean(info.pk),
+        }))
+    }
+}

package/Database/Drivers/SQLite/index.ts

@@ -0,0 +1,15 @@
+import { Entity } from '../../Entity'
+import { JSONField, PrimaryField } from '../../Fields'
+
+export * from './SqliteDriver'
+
+// 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/SchemaContract.ts

@@ -0,0 +1,11 @@
+import { ColumnField, Entity, EntityMetadata } from '..'
+import { DatabaseDriver } from './DatabaseDriver'
+
+export abstract class SchemaContract {
+    constructor(public driver: DatabaseDriver) {}
+
+    abstract create(table: string, columns: ColumnField<Entity>[]): Promise<void>
+
+    abstract synchronize(entitiesMetadata: EntityMetadata<Entity, Entity>[]): Promise<void>
+
+}

package/Database/Drivers/Statement.ts

@@ -0,0 +1,16 @@
+import { Components, SqlValue } from '../Types'
+import { StringExpression } from '../StringExpression'
+
+export abstract class Statement extends StringExpression {
+    bindings: SqlValue[] = []
+
+    constructor(public components: Components) {
+        super('')
+    }
+
+    abstract toSQL(): string;
+
+    toString() {
+        return this.toSQL()
+    }
+}

package/Database/Drivers/index.ts

@@ -0,0 +1,4 @@
+export * from './SQLite/SqliteDriver'
+export * from './MySQL/MysqlDriver'
+export * from './Statement'
+export * from './SchemaContract'