@typetron/framework 0.4.0-rc9 → 0.5.0

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'

package/Database/Entity.ts

@@ -0,0 +1,377 @@
+import { EntityProxyHandler } from './EntityProxyHandler'
+import { EntityQuery } from './EntityQuery'
+import { ChildObject, KeysOfType } from '../Support'
+import { EntityMetadata, EntityMetadataKey, ID } from './Decorators'
+import { EntityNotFoundError } from './EntityNotFoundError'
+import { BelongsTo, BelongsToMany, ColumnField, HasMany, HasOne, InverseField } from './Fields'
+import { BooleanOperator, Direction, Operator, WhereFunction, WhereValue } from './Types'
+import { DotNotationProperties, EntityConstructor, EntityKeys, EntityObject } from './index'
+import { Query } from './Query'
+import { List } from './List'
+
+export abstract class Entity {
+
+    exists = false
+    // tslint:disable-next-line:no-any
+    original: Record<string, any> = {}
+
+    constructor() {
+        const entityProxyHandler = new EntityProxyHandler<this>()
+        const proxy = new Proxy(this, entityProxyHandler)
+
+        // Weird JS issues: "filling" an instance with data is not possible since the default values of child entities
+        //  are assigned after the constructor of base class (this constructor exactly) is called.
+        //  Calling "proxy.fill will update the instance but then the default values will overwrite them"
+        // proxy.fill(this.original = data || {})
+
+        return proxy
+    }
+
+    static get metadata(): EntityMetadata<Entity, Entity> {
+        return Reflect.getMetadata(EntityMetadataKey, this.prototype) ?? new EntityMetadata<Entity, Entity>()
+    }
+
+    get metadata(): EntityMetadata<Entity, Entity> {
+        return this.static.metadata
+    }
+
+    get static(): EntityConstructor<this> {
+        return this.constructor as EntityConstructor<this>
+    }
+
+    static where<T extends Entity, K extends EntityKeys<T>>(
+        this: EntityConstructor<T>,
+        column: EntityKeys<T>,
+        operator: Operator | Query | WhereValue | T[K],
+        value?: Query | WhereValue | T[K],
+        boolean?: BooleanOperator
+    ): EntityQuery<T> {
+        const columnMetadata = {
+            ...this.metadata.columns,
+            ...this.metadata.relationships
+        }[column as string]
+        return this.newQuery().where(columnMetadata.column, operator, value, boolean)
+    }
+
+    static whereIn<T extends Entity, K extends EntityKeys<T>>(
+        this: EntityConstructor<T>,
+        column: EntityKeys<T>,
+        value: Query | WhereValue[] | T[K][],
+        boolean?: BooleanOperator
+    ): EntityQuery<T> {
+        const columnMetadata = {
+            ...this.metadata.columns,
+            ...this.metadata.relationships
+        }[column as string]
+        return this.newQuery().whereIn(columnMetadata.column, value, boolean)
+    }
+
+    static whereNotIn<T extends Entity, K extends EntityKeys<T>>(
+        this: EntityConstructor<T>,
+        column: EntityKeys<T>,
+        value: Query | WhereFunction | WhereValue[] | T[K][]
+    ): EntityQuery<T> {
+        const columnMetadata = {
+            ...this.metadata.columns,
+            ...this.metadata.relationships
+        }[column as string]
+        return this.newQuery().whereNotIn(columnMetadata.column, value)
+    }
+
+    static whereLike<T extends Entity, K extends EntityKeys<T>>(
+        this: EntityConstructor<T>,
+        column: EntityKeys<T>,
+        value?: WhereValue | T[K],
+        boolean?: BooleanOperator
+    ): EntityQuery<T> {
+        const columnMetadata = {
+            ...this.metadata.columns,
+            ...this.metadata.relationships
+        }[column as string]
+        return this.newQuery().whereLike(columnMetadata.column, value as WhereValue, boolean)
+    }
+
+    static async first<T extends Entity, K extends EntityKeys<T>>(
+        this: EntityConstructor<T>,
+        ...columns: EntityKeys<T>[]
+    ): Promise<T | undefined> {
+        return this.newQuery().first(...columns)
+    }
+
+    // static first2: <T extends Entity>(this: EntityConstructor<T>, ...params: Parameters<Query<T>['first']>) =>  Query<T>['first'];
+
+    // tslint:disable-next-line:no-any
+    static async firstOrNew<T extends Entity, K extends keyof Entity>(
+        this: EntityConstructor<T>,
+        properties: Partial<EntityObject<T>>,
+        values?: Partial<EntityObject<T>>
+    ): Promise<T> {
+        return this.newQuery().firstOrNew(properties, values)
+    }
+
+    // tslint:disable-next-line:no-any
+    static async firstOrCreate<T extends Entity, K extends keyof Entity>(
+        this: EntityConstructor<T>,
+        properties: Partial<EntityObject<T>>,
+        values?: Partial<EntityObject<T>>
+    ): Promise<T> {
+        return (await this.firstOrNew(properties, values)).save()
+    }
+
+    static orderBy<T extends Entity, K extends EntityKeys<T>>(
+        this: EntityConstructor<T>,
+        column: EntityKeys<T>,
+        direction?: Direction
+    ): EntityQuery<T> {
+        return this.newQuery().orderBy(column, direction)
+    }
+
+    static getTable<T extends Entity>(this: EntityConstructor<T>): string {
+        return this.metadata.table || this.name.toLowerCase() // TODO make metadata.table un-optional
+    }
+
+    static new<T extends Entity, K extends keyof T>(
+        this: EntityConstructor<T>,
+        data: Partial<ChildObject<T, Entity>> | {},
+        exists = false
+    ): T {
+        const instance = new (this as any)()
+        instance.fill(instance.original = data)
+        instance.exists = exists
+
+        return instance
+    }
+
+    static create<T extends Entity>(this: EntityConstructor<T>, data?: ChildObject<T, Entity> | {}): Promise<T> {
+        return this.new(data ?? {}).save()
+    }
+
+    static async insert<T extends Entity>(this: EntityConstructor<T>, data: (ChildObject<T, Entity> | {})[]): Promise<void> {
+        const dataToSave = data.map(piece => {
+            const instance = this.new(piece)
+            return instance.getDataToSave(piece)
+        })
+
+        const query = this.newQuery()
+
+        await query.insert(dataToSave)
+    }
+
+    static async get<T extends Entity>(this: EntityConstructor<T>, ...columns: EntityKeys<T> []): Promise<T[]> {
+        return this.newQuery().get(...columns)
+    }
+
+    static with<T extends Entity>(
+        this: EntityConstructor<T>,
+        ...relations: (
+            // tslint:disable-next-line:no-any
+            KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<T> |
+            // tslint:disable-next-line:no-any max-line-length
+            [KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<T>, (Query: EntityQuery<any>) => void]
+            )[]
+    ) {
+        return this.newQuery().with(...relations)
+    }
+
+    static withCount<T extends Entity, K extends KeysOfType<T, List<Entity>>>(
+        this: EntityConstructor<T>,
+        ...relations: (
+            // tslint:disable-next-line:no-any
+            KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<T> |
+            // tslint:disable-next-line:no-any max-line-length
+            [KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<T>, (Query: EntityQuery<any>) => void]
+            )[]
+    ) {
+        return this.newQuery().withCount(...relations)
+    }
+
+    static async find<T extends Entity>(this: EntityConstructor<T>, id: string | number | ID): Promise<T | undefined> {
+        return this.newQuery().where('id' as keyof T, id as number).first()
+    }
+
+    static async findOrFail<T extends Entity>(this: EntityConstructor<T>, id: string | number | ID): Promise<T> {
+        const query = this.newQuery().where('id' as keyof T, id as number)
+        const instance = await query.first()
+        if (!instance || !Object.entries(instance).length) {
+            throw new EntityNotFoundError(this, `No records found for entity '${this.name}' when querying with parameters [${query.getBindings().join(', ')}]`)
+        }
+        return instance
+    }
+
+    static getPrimaryKey<T extends Entity>(): EntityKeys<T> {
+        return 'id' as EntityKeys<T>
+    }
+
+    static hydrate<T extends Entity>(modelType: EntityConstructor<T>, models: Partial<ChildObject<T, Entity>>[], exist = false) {
+        return models.map(data => {
+            return modelType.new(data, exist)
+        })
+    }
+
+    static newQuery<T extends Entity>(this: EntityConstructor<T>): EntityQuery<T> {
+        return (new EntityQuery(this)).table(this.getTable()) as EntityQuery<T>
+    }
+
+    getTable(): string {
+        return this.static.getTable()
+    }
+
+    async load(
+        ...relations: (
+            // tslint:disable-next-line:no-any
+            KeysOfType<this, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this> |
+            // tslint:disable-next-line:no-any max-line-length
+            [KeysOfType<this, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this>, (Query: EntityQuery<any>) => void]
+            )[]
+    ) {
+        await this.newQuery().with(...relations).eagerLoadRelationships([this])
+
+        return this
+    }
+
+    async loadCount<K extends KeysOfType<this, List<Entity>>>(
+        ...relations: (
+            // tslint:disable-next-line:no-any
+            KeysOfType<this, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this> |
+            // tslint:disable-next-line:no-any max-line-length
+            [KeysOfType<this, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this>, (Query: EntityQuery<any>) => void]
+            )[]
+    ) {
+        await this.newQuery().withCount<K>(...relations).eagerLoadRelationshipsCounts([this])
+
+        return this
+    }
+
+    newQuery<T extends Entity>(this: T) {
+        return this.static.newQuery()
+    }
+
+    static async delete<T extends Entity>(this: EntityConstructor<T>, ...ids: [ID, ...ID[]]) {
+        await this.newQuery().whereIn(this.getPrimaryKey(), ids).delete()
+    }
+
+    private getDataToSave(data: ChildObject<this, Entity> | object) {
+        this.fill(data)
+
+        this.updateTimestamps()
+
+        // tslint:disable-next-line:no-any
+        const dataToSave: Record<string, any> = {}
+
+        // TODO diff the values so we don't update every value from the entity
+        Object.values({...this.metadata.columns, ...this.metadata.relationships}).forEach(field => {
+            dataToSave[field.column] = field.value(this, field.property)
+        })
+        return dataToSave
+    }
+
+
+    fill(data: ChildObject<this, Entity> | object) {
+        // TODO, check if we need to uncomment this
+        // const relationships = this.metadata.relationships
+        // Object.keys(relationships).forEach(key => {
+        //     relationships[key].update(this)
+        // })
+        const fields = {...this.metadata.columns, ...this.metadata.relationships, ...this.metadata.inverseRelationships}
+        Object.keys(data).forEach(key => {
+            const field = fields[key]
+            if (field) {
+                const value = data[key as keyof object]
+                field.set(this, this.convertValueByType(value, field))
+            }
+        })
+
+        return this
+    }
+
+    async delete() {
+        if (!this.exists) {
+            return
+        }
+
+        await this.newQuery().where(this.getPrimaryKey(), this[this.getPrimaryKey()]).delete()
+    }
+
+    static async truncate<T extends Entity>(this: EntityConstructor<T>) {
+        await this.newQuery().truncate()
+    }
+
+    async save(data: ChildObject<this, Entity> | object = {}): Promise<this> {
+        const dataToSave = this.getDataToSave(data)
+
+        const query = this.newQuery()
+
+        if (this.exists) {
+            delete dataToSave[this.getPrimaryKey() as string]
+            await query.where(this.getPrimaryKey(), this[this.getPrimaryKey()]).update(dataToSave)
+        } else {
+            const id = await query.insertOne(dataToSave)
+            this.exists = true
+            this.fill({id})
+        }
+
+        return this
+    }
+
+    getPrimaryKey<T extends Entity>(this: T): EntityKeys<T> {
+        return this.static.getPrimaryKey()
+    }
+
+    getPrimaryKeyValue<T extends Entity>(this: T): ID {
+        return this[this.static.getPrimaryKey()]
+    }
+
+    toJSON() {
+        return Object.keys({...this.metadata.columns, ...this.metadata.allRelationships})
+            .reduce((obj, key) => {
+                if (Object.prototype.hasOwnProperty.call(this, key)) {
+                    obj[key as keyof this] = this[key as keyof this]
+                }
+                return obj
+            }, {} as { [K in keyof this]: this[K] })
+    }
+
+    private updateTimestamps() {
+        const metadata = this.metadata
+        const columnsToFill: Record<keyof this, unknown> = {} as Record<keyof this, unknown>
+
+        const createdAtValue = metadata.createdAtColumn ? this[metadata.createdAtColumn as keyof this] as unknown as Date : undefined
+        if (metadata.createdAtColumn && !createdAtValue) {
+            columnsToFill[metadata.createdAtColumn as keyof this] = new Date()
+        }
+
+        const updatedAtValue = metadata.updatedAtColumn ? this[metadata.updatedAtColumn as keyof this] as unknown as Date : undefined
+        if (metadata.updatedAtColumn &&
+            (!updatedAtValue || updatedAtValue?.getTime() === new Date(this.original[metadata.updatedAtColumn]).getTime())
+        ) {
+            columnsToFill[metadata.updatedAtColumn as keyof this] = new Date()
+        }
+
+        this.fill(columnsToFill)
+    }
+
+    private convertValueByType(value: unknown, property: ColumnField<Entity> | InverseField<Entity>) {
+        const converter = types.get(property.type()) || (() => value)
+        return converter(value)
+    }
+}
+
+const types: Map<Function, Function> = new Map()
+types.set(Date, (value: number | string) => value ? new Date(value) : value)
+types.set(String, (value: object) => value ? String(value) : value)
+types.set(Boolean, (value: string) => Boolean(value))
+
+// let handler = {
+// 	set: (target, prop, value) => {
+// 		console.log(target, prop, value);
+// 		target[prop] = value;
+// 		return true;
+// 	},
+// 	get: (target, prop) => {
+// 		if(!(prop in Entity))
+// 			return () => {return new Query};
+// 		return target[prop];
+// 	}
+// };
+
+// Object.setPrototypeOf(Entity, new Proxy({}, new EntityProxyHandler(Entity)));

package/Database/EntityNotFoundError.ts

@@ -0,0 +1,5 @@
+import { Entity } from './Entity'
+
+export class EntityNotFoundError extends Error {
+    constructor(public entity: typeof Entity, message: string) {super(message)}
+}

package/Database/EntityProxyHandler.ts

@@ -0,0 +1,43 @@
+import { Entity } from './Entity'
+import { EntityQuery } from './EntityQuery'
+import { EntityConstructor } from './index'
+
+export class EntityProxyHandler<T extends Entity> {
+
+    set<K extends keyof T>(target: T, property: string, value: T[K]) {
+        target[property as keyof T] = value
+        return true
+    }
+
+    get(target: T, property: string) {
+        if (!(property in target)) {
+            const targetConstructor = target.constructor as EntityConstructor<T>
+            const query = new EntityQuery(targetConstructor)
+            const queryProperty = query[property as keyof EntityQuery<T>] as Function
+            if (typeof queryProperty === 'function') {
+                // @ts-ignore
+                query.table(target.constructor.getTable())
+                return (...args: object[]) => {
+                    return queryProperty.apply(query, args)
+                }
+            }
+        }
+
+        const value = target[property as keyof T]
+
+        if (!value) {
+            const relationships = target.metadata.allRelationships
+            if (relationships[property]) {
+                const relationship = new (relationships[property] as any)
+                const relationshipClass = relationship.relationClass(relationships[property], target) as unknown as T[keyof T]
+                return target[property as keyof T] = relationshipClass
+            }
+        }
+
+        return value
+        // if (typeof value === 'function') {
+        //     return value.bind(target);
+        // }
+        // return value;
+    }
+}