@typetron/framework 0.5.20 → 0.5.22

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 = (relationships[property] as any)
+                const relationshipClass = new 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;
+    }
+}

package/Database/EntityQuery.ts

@@ -0,0 +1,197 @@
+import { Query } from './Query'
+import { Entity } from './Entity'
+import { DotNotationProperties, EntityConstructor, EntityObject, StringExpression } from './index'
+import { KeysOfType } from '@Typetron/Support'
+import { BelongsTo, BelongsToMany, HasMany, HasOne } from './Fields'
+import { List } from './List'
+import { RelationsTree, RelationsTreeQuery } from './Types'
+
+export class EntityQuery<T extends Entity> extends Query<T> {
+
+    // tslint:disable-next-line:no-any
+    eagerLoad: (string | [string, RelationsTreeQuery])[] = []
+    // tslint:disable-next-line:no-any
+    eagerLoadCount: (string | [string, RelationsTreeQuery])[] = []
+
+    constructor(public entity: EntityConstructor<T>) {
+        super()
+    }
+
+    async get<K extends keyof T>(...columns: (K | string | StringExpression)[]): Promise<T[]> {
+        let entities = await super.get(...columns)
+
+        entities = this.entity.hydrate(this.entity, entities, true)
+
+        entities = await this.eagerLoadRelationships(entities)
+
+        return await this.eagerLoadRelationshipsCounts(entities)
+    }
+
+    public async eagerLoadRelationships(entities: T[]) {
+
+        const relationsTree = this.tree(this.eagerLoad)
+
+        await Object.keys(relationsTree).forEachAsync(async (relationName) => {
+            const relationValue = relationsTree[relationName]
+            const relation = this.entity.metadata.allRelationships[relationName]
+
+            if (!relation) {
+                throw new Error(`Relation '${relationName}' doesn't not exist on entity '${this.entity.name}'`)
+            }
+
+            // tslint:disable-next-line:no-any
+            let fieldQueryFunction: undefined | RelationsTreeQuery
+            let otherRelations: this['eagerLoad'] = []
+            if (relationValue instanceof Function) {
+                fieldQueryFunction = relationValue
+            } else {
+                otherRelations = this.treeBack(relationValue)
+            }
+
+            const results = await relation.getRelatedValue(entities, otherRelations, fieldQueryFunction as (query: Query) => void)
+
+            // if (results.length) {
+                entities = relation.match(entities, results) as T[]
+            // }
+        })
+        // await this.eagerLoad.forEachAsync(async (field) => {
+        //     // tslint:disable-next-line:no-any
+        //     let fieldName: string, fieldQueryFunction: undefined | RelationsTreeQuery
+        //     if (field instanceof Array) {
+        //         fieldName = field[0]
+        //         fieldQueryFunction = field[1]
+        //     } else {
+        //         fieldName = field
+        //     }
+        //     const [first, ...rest] = fieldName.split('.')
+        //     const relation = this.entity.metadata.allRelationships[first]
+        //     const results = await relation.getRelatedValue(entities, [rest.join('.')], fieldQueryFunction as (query: Query) => void)
+        //     if (results.length) {
+        //         entities = relation.match(entities, results) as T[]
+        //     }
+        // })
+        return entities
+    }
+
+    public async eagerLoadRelationshipsCounts(entities: T[]) {
+        await this.eagerLoadCount.forEachAsync(async (field) => {
+            // tslint:disable-next-line:no-any
+            let fieldName: string, fieldQueryFunction: undefined | RelationsTreeQuery
+            if (field instanceof Array) {
+                fieldName = field[0]
+                fieldQueryFunction = field[1]
+            } else {
+                fieldName = field
+            }
+
+            const relation = this.entity.metadata.allRelationships[fieldName]
+            const results = await relation.getRelatedCount(entities, fieldQueryFunction as ((query: Query) => void))
+            if (results.length) {
+                entities = relation.matchCounts(entities, results) as T[]
+            }
+        })
+        return entities
+    }
+
+    async first<K extends keyof T>(...columns: (K | string | StringExpression)[]): Promise<T | undefined> {
+        const entityData = await super.first(...columns)
+        if (!entityData) {
+            return undefined
+        }
+        let entity = this.entity.new(entityData, true)
+
+        entity = (await this.eagerLoadRelationships([entity])).first() as T
+
+        return (await this.eagerLoadRelationshipsCounts([entity])).first()
+    }
+
+    async firstOrNew<K extends keyof T>(
+        // tslint:disable-next-line:no-any
+        properties: Partial<EntityObject<T> | Record<string, any>>,
+        values?: Partial<EntityObject<T>>
+    ): Promise<T> {
+        Object.entries(properties).forEach(([property, value]) => {
+            const field = this.entity.metadata.columns[property] || this.entity.metadata.relationships[property]
+            const finalValue = value instanceof Entity ? value[value.getPrimaryKey()] : value
+            if (finalValue === undefined) {
+                this.andWhereNull(field.column)
+            } else {
+                this.andWhere(field.column, finalValue)
+            }
+        })
+        const instance = await this.first()
+        if (!instance) {
+            return this.entity.new({...properties, ...values})
+        }
+        instance.exists = true
+        return instance
+    }
+
+    with(
+        ...relations: (
+            // tslint:disable-next-line:no-any
+            KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this> |
+            // tslint:disable-next-line:no-any max-line-length
+            [KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this>, RelationsTreeQuery]
+            )[]
+    ) {
+        relations = relations.filter(Boolean)
+        if (relations.length) {
+            // tslint:disable-next-line:no-any
+            this.eagerLoad = this.eagerLoad.concat(relations as string | [string, RelationsTreeQuery]).unique()
+        }
+
+        return this
+    }
+
+    withCount<K extends KeysOfType<T, List<Entity>>>(
+        ...relations: (
+            // tslint:disable-next-line:no-any
+            KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this> |
+            // tslint:disable-next-line:no-any max-line-length
+            [KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this>, RelationsTreeQuery]
+            )[]
+    ) {
+        // @ts-ignore
+        this.eagerLoadCount = this.eagerLoadCount.concat(relations)
+
+        return this
+    }
+
+    private tree(relations: this['eagerLoad']) {
+        const tree: RelationsTree = {}
+
+        relations.forEach(relation => {
+            let relationName: string
+            let relationValue: RelationsTreeQuery | {} = {}
+            if (relation instanceof Array) {
+                relationName = relation[0]
+                relationValue = relation[1]
+            } else {
+                relationName = relation
+            }
+
+            let container = tree
+            const relationStringParts = relationName.split('.')
+            relationStringParts.forEach((part, index) => {
+                const value = index === relationStringParts.length - 1 ? relationValue : {}
+                // @ts-ignore
+                container = (container[part] ? container[part] : container[part] = value)
+            })
+        })
+
+        return tree
+    }
+
+    private treeBack(relationsTree: RelationsTree): this['eagerLoad'] {
+        return Object.keys(relationsTree).map(relationName => {
+            const item = relationsTree[relationName]
+
+            if (item instanceof Function) {
+                return [relationName, item]
+            } else {
+                return [relationName, this.treeBack(item)].filter(Boolean).join('.')
+            }
+        })
+    }
+}

package/Database/Expression.ts

@@ -0,0 +1,3 @@
+export abstract class Expression {
+    abstract toSQL(): string
+}