@typetron/framework 0.5.0 → 0.5.3

package/Database/Drivers/SQLite/SqliteDriver.ts

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

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

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

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

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

package/Database/Entity.ts

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

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

package/Database/EntityProxyHandler.ts

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