@typetron/framework 0.5.21 → 0.5.22

package/Database/Connection.ts

@@ -0,0 +1,52 @@
+import { Query } from './Query'
+import { DatabaseDriver } from './Drivers/DatabaseDriver'
+import { SqlValue } from './Types'
+
+export class Connection {
+
+    constructor(public driver: DatabaseDriver) {}
+
+    async run(query: Query): Promise<void> {
+        return this.driver.run(query.toSQL(), query.getBindings())
+    }
+
+    async insertOne(query: Query): Promise<number> {
+        return this.driver.insertOne(query.toSQL(), query.getBindings())
+    }
+
+    truncate(table: string) {
+        return this.driver.truncate(table)
+    }
+
+    async get<T>(query: Query<T>): Promise<T[]> {
+        return await this.driver.get<T>(query.toSQL(), query.getBindings()) as T[]
+    }
+
+    async first<T>(query: Query<T>): Promise<T | undefined> {
+        return await this.driver.first(query.toSQL(), query.getBindings()) as T
+    }
+
+    async getRaw<T>(rawQuery: string, params: SqlValue[] = []): Promise<T[]> {
+        return await this.driver.get(rawQuery, params) as T[]
+    }
+
+    async firstRaw<T>(rawQuery: string, params: SqlValue[] = []): Promise<T> {
+        return await this.driver.first(rawQuery, params) as T
+    }
+
+    async runRaw(rawQuery: string, params: SqlValue[] = []): Promise<void> {
+        return this.driver.run(rawQuery, params)
+    }
+
+    async tables() {
+        return this.driver.tables()
+    }
+
+    async tableExists(table: string) {
+        return this.driver.tableExists(table)
+    }
+
+    async tableColumns(table: string) {
+        return this.driver.tableColumns(table)
+    }
+}

package/Database/Decorators.ts

@@ -0,0 +1,142 @@
+import { ChildObject, Constructor, KeysOfType } from '@Typetron/Support'
+import { Entity } from './Entity'
+import {
+    BelongsTo,
+    BelongsToMany,
+    BelongsToManyField,
+    BelongsToManyFieldOptions,
+    ColumnField,
+    HasMany,
+    HasManyField,
+    HasOne,
+    HasOneField,
+    JSONField,
+    PrimaryField,
+    RelationshipField
+} from './Fields'
+import { EntityConstructor } from './index'
+import { List } from './List'
+import { BaseRelationship } from './ORM/BaseRelationship'
+
+export const EntityMetadataKey = 'framework:entity'
+
+export type ID = number | string;
+
+export class EntityOptions<T extends Entity> {
+    table?: string
+    touch?: KeysOfType<T, Entity | List<T, Entity>>[]
+}
+
+export class EntityMetadata<T extends Entity, R extends Entity> extends EntityOptions<T> {
+    columns: Record<string, ColumnField<T>> = {}
+    relationships: Record<string, RelationshipField<T, R>> = {}
+    inverseRelationships: Record<string, BelongsToManyField<T, R> | HasManyField<T, R> | HasOneField<T, R>> = {}
+    createdAtColumn?: string
+    updatedAtColumn?: string
+
+    get allRelationships() {
+        return {...this.relationships, ...this.inverseRelationships}
+    }
+
+    static get<T extends Entity, R extends Entity>(entity: T) {
+        const metadata: EntityMetadata<T, R> = Reflect.getMetadata(EntityMetadataKey, entity) || new this()
+        metadata.table = metadata?.table || entity.constructor.name.toLowerCase()
+        return metadata
+    }
+}
+
+export function Options<T extends Entity>(options: EntityOptions<T> = {}) {
+    return (entity: object) => {
+        const entityClass = entity as unknown as EntityConstructor<T>
+        const metadata = EntityMetadata.get(entityClass.prototype)
+        options.table = options.table || entityClass.name.toLowerCase()
+        Object.assign(metadata, options)
+        Reflect.defineMetadata(EntityMetadataKey, metadata, entityClass.prototype)
+    }
+}
+
+function setField<T extends Entity>(entity: T, field: ColumnField<T>) {
+    const entityMetadata = EntityMetadata.get(entity)
+    entityMetadata.columns[field.property] = field
+    Reflect.defineMetadata(EntityMetadataKey, entityMetadata, entity)
+}
+
+export function Column<T extends Entity>(column?: string | {type: any}, options?: {type: any}): PropertyDecorator {
+    return function(entity: Object, name: string | symbol) {
+        const actualColumn: string | undefined = typeof column === 'string' ? column : undefined
+        const type = options?.type ?? Reflect.getMetadata('design:type', entity, name)
+        const field = new ColumnField(entity.constructor as EntityConstructor<T>, String(name), () => type, actualColumn || String(name))
+        setField(entity as T, field)
+    }
+}
+
+export function JSONColumn<T extends Entity>(column?: string) {
+    return function(entity: object, name: string) {
+        const field = new JSONField(entity.constructor as EntityConstructor<T>, name, () => String, column || name)
+        setField(entity as T, field)
+    }
+}
+
+export function Enum<T extends Entity>(...values: string[]) {
+    return function(entity: object, name: string) {
+    }
+}
+
+export function PrimaryColumn<T extends Entity>(column?: string) {
+    return function(entity: object, name: string) {
+        const type = Reflect.getMetadata('design:type', entity, name)
+        const field = new PrimaryField(entity.constructor as EntityConstructor<T>, name, () => type, column || name)
+        setField(entity as T, field)
+    }
+}
+
+export function CreatedAt<T extends Entity>(column?: string) {
+    return function(entity: object, name: string) {
+        Column(column)(entity as T, name)
+        const entityMetadata = EntityMetadata.get(entity as T)
+        entityMetadata.createdAtColumn = column || name
+        Reflect.defineMetadata(EntityMetadataKey, entityMetadata, entity)
+    }
+}
+
+export function UpdatedAt<T extends Entity>(column?: string) {
+    return function(entity: object, name: string) {
+        Column(column)(entity as T, name)
+        const entityMetadata = EntityMetadata.get(entity as T)
+        entityMetadata.updatedAtColumn = column || name
+        Reflect.defineMetadata(EntityMetadataKey, entityMetadata, entity)
+    }
+}
+
+type RelationshipsList = typeof BelongsTo | typeof HasOne | typeof HasMany | typeof BelongsToMany;
+const entityOptionsCache = new Map<Entity, Record<string, object>>()
+
+export function Relation<T extends Entity, R extends Entity>(
+    type: () => Constructor<R>,
+    // tslint:disable-next-line:no-any
+    // inverseBy: KeysOfType<Omit<R, keyof Entity>, Entity | HasOne<any> | BelongsTo<any> | HasMany<any> | BelongsToMany<any>>,
+    // tslint:disable-next-line:no-any
+    // inverseBy: KeysOfType<R, Entity | HasOne<any> | BelongsTo<any> | HasMany<any> | BelongsToMany<any>>,
+    // tslint:disable-next-line:no-any
+    inverseBy: KeysOfType<ChildObject<R, Entity>, BaseRelationship<T>>,
+    // options: Partial<RelationshipOptions> = {}
+) {
+    return function(entity: object, property: string) {
+        let entityMetadata = EntityMetadata.get(entity as T)
+        const fieldClass = Reflect.getMetadata('design:type', entity, property) as RelationshipsList
+        const entityClass = entity.constructor as EntityConstructor<T>
+
+        const options = entityOptionsCache.get(entity as T) || {}
+        // @ts-ignore
+        entityMetadata = fieldClass.relationship(entityMetadata, entityClass, property, type, inverseBy as string, options[property])
+        Reflect.defineMetadata(EntityMetadataKey, entityMetadata, entity)
+    }
+}
+
+export function BelongsToManyOptions<T extends Entity>(options: BelongsToManyFieldOptions) {
+    return function(entity: object, property: string) {
+        const entityOptions = entityOptionsCache.get(entity as T) || {}
+        entityOptions[property] = options
+        entityOptionsCache.set(entity as T, entityOptions)
+    }
+}

package/Database/Drivers/DatabaseDriver.ts

@@ -0,0 +1,37 @@
+import { SqlValue } from '../Types'
+import { Statement } from './Statement'
+import { Constructor } from '@Typetron/Support'
+import { SchemaContract } from './SchemaContract'
+import { ColumnDefinitionOptions } from '@Typetron/Database/Drivers/SQL'
+
+interface StatementsList {
+    create: Constructor<Statement>,
+    select: Constructor<Statement>,
+    insert: Constructor<Statement>,
+    delete: Constructor<Statement>,
+    update: Constructor<Statement>,
+    alter: Constructor<Statement>,
+}
+
+export abstract class DatabaseDriver {
+
+    abstract statements: StatementsList
+
+    abstract schema: SchemaContract
+
+    abstract run(query: string, params?: SqlValue[]): Promise<void>
+
+    abstract truncate(table: string): Promise<void>
+
+    abstract insertOne(query: string, params: SqlValue[]): Promise<number>
+
+    abstract get<T>(query: string, params: SqlValue[]): Promise<T | T[]>
+
+    abstract first<T>(query: string, params: SqlValue[]): Promise<T | undefined>
+
+    abstract tables(): Promise<{name: string}[]>
+
+    abstract tableExists(table: string): Promise<boolean>
+
+    abstract tableColumns(table: string): Promise<ColumnDefinitionOptions[]>
+}

package/Database/Drivers/MySQL/Alter/index.ts

@@ -0,0 +1,55 @@
+import { ColumnDefinitionOptions } from '../../../Drivers/SQL'
+import { wrap } from '../../../Helpers'
+import { ColumnDefinition } from '@Typetron/Database/Drivers/MySQL/ColumnDefinition'
+import { Expression } from '@Typetron/Database'
+
+export enum Constraints {
+    PrimaryKey = 'PRIMARY KEY',
+    ForeignKey = 'FOREIGN KEY',
+}
+
+export abstract class AlterOption extends Expression {
+    constructor(public column: ColumnDefinitionOptions) {super()}
+
+    abstract toSQL(): string
+}
+
+export class AddColumn extends AlterOption {
+    toSQL(): string {
+        return `ADD ${new ColumnDefinition(this.column).toSQL()}`
+    }
+}
+
+export class AddConstraint extends AlterOption {
+
+    constructor(column: ColumnDefinitionOptions, public type: Constraints) {super(column)}
+
+    toSQL(): string {
+        return `ADD CONSTRAINT ${this.type} (${this.column.name})`
+    }
+}
+
+export class ModifyColumn extends AlterOption {
+    toSQL(): string {
+        return `MODIFY ${new ColumnDefinition(this.column).toSQL()}`
+    }
+}
+
+export class DropColumn extends Expression {
+    constructor(public column: string) {super()}
+
+    toSQL(): string {
+        return `DROP COLUMN ${wrap(this.column)}`
+    }
+}
+
+export class Alter extends Expression {
+    constructor(public table: string, public alterOptions: Expression[]) {super()}
+
+    toSQL() {
+        return `
+            ALTER TABLE ${wrap(this.table)}
+                ${this.alterOptions.map(option => option.toSQL()).join(', \n')}
+        `
+    }
+}

package/Database/Drivers/MySQL/ColumnDefinition.ts

@@ -0,0 +1,16 @@
+import { ColumnDefinitionOptions } from '../../Drivers/SQL'
+import { wrap } from '../../Helpers'
+
+export class ColumnDefinition {
+    constructor(public options: ColumnDefinitionOptions) {}
+
+    toSQL() {
+        const sqlParts = [wrap(this.options.name), this.options.type]
+
+        if (this.options.autoIncrement) {
+            sqlParts.push('AUTO_INCREMENT')
+        }
+
+        return sqlParts.join(' ')
+    }
+}

package/Database/Drivers/MySQL/Create.ts

@@ -0,0 +1,47 @@
+import { BaseStatement } from '../SQL/Statements/BaseStatement'
+import { ColumnDefinitionOptions } from '../SQL'
+import { wrap } from '../../Helpers'
+
+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)
+
+        this.columns.where('primaryKey').whenNotEmpty(primaryColumns => {
+            definitions.push(`PRIMARY KEY (${primaryColumns.pluck('name').join(', ')})`)
+        })
+
+        return `
+            CREATE TABLE ${this.table}
+            (
+                ${definitions.join(', \n')}
+            )
+        `
+    }
+
+    private getColumnsSQL(columns: ColumnDefinitionOptions[]) {
+        return columns.map(this.getColumnSQL)
+    }
+
+    private getColumnSQL(column: ColumnDefinitionOptions) {
+        const sqlParts = [wrap(column.name), column.type]
+
+        if (column.autoIncrement) {
+            sqlParts.push('AUTO_INCREMENT')
+        }
+
+        return sqlParts.join(' ')
+    }
+}

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