@typetron/framework 0.5.22 → 0.5.25

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 = (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

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

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