@typetron/framework 0.5.22 → 0.5.25

package/Database/Connection.ts

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

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

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

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

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

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

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