@typetron/framework 0.3.17 → 0.3.18

package/Database/EntityProxyHandler.js

@@ -1,31 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityProxyHandler = void 0;
-const EntityQuery_1 = require("./EntityQuery");
-class EntityProxyHandler {
-    set(target, property, value) {
-        target[property] = value;
-        return true;
-    }
-    get(target, property) {
-        if (!(property in target)) {
-            const targetConstructor = target.constructor;
-            const query = new EntityQuery_1.EntityQuery(targetConstructor);
-            const queryProperty = query[property];
-            if (typeof queryProperty === 'function') {
-                // @ts-ignore
-                query.table(target.constructor.getTable());
-                return (...args) => {
-                    return queryProperty.apply(query, args);
-                };
-            }
-        }
-        return target[property];
-        // if (typeof value === 'function') {
-        //     return value.bind(target);
-        // }
-        // return value;
-    }
-}
-exports.EntityProxyHandler = EntityProxyHandler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityProxyHandler = void 0;
+const EntityQuery_1 = require("./EntityQuery");
+class EntityProxyHandler {
+    set(target, property, value) {
+        target[property] = value;
+        return true;
+    }
+    get(target, property) {
+        if (!(property in target)) {
+            const targetConstructor = target.constructor;
+            const query = new EntityQuery_1.EntityQuery(targetConstructor);
+            const queryProperty = query[property];
+            if (typeof queryProperty === 'function') {
+                // @ts-ignore
+                query.table(target.constructor.getTable());
+                return (...args) => {
+                    return queryProperty.apply(query, args);
+                };
+            }
+        }
+        return target[property];
+        // if (typeof value === 'function') {
+        //     return value.bind(target);
+        // }
+        // return value;
+    }
+}
+exports.EntityProxyHandler = EntityProxyHandler;
 //# sourceMappingURL=EntityProxyHandler.js.map

package/Database/EntityQuery.d.ts

@@ -1,29 +1,29 @@
-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 { RelationsTreeQuery } from './Types';
-export declare class EntityQuery<T extends Entity> extends Query<T> {
-    entity: EntityConstructor<T>;
-    eagerLoad: (string | [string, RelationsTreeQuery])[];
-    eagerLoadCount: (string | [string, RelationsTreeQuery])[];
-    constructor(entity: EntityConstructor<T>);
-    get<K extends keyof T>(...columns: (K | string | StringExpression)[]): Promise<T[]>;
-    eagerLoadRelationships(entities: T[]): Promise<T[]>;
-    eagerLoadRelationshipsCounts(entities: T[]): Promise<T[]>;
-    first<K extends keyof T>(...columns: (K | string | StringExpression)[]): Promise<T | undefined>;
-    firstOrNew<K extends keyof T>(properties: Partial<EntityObject<T> | Record<string, any>>, values?: Partial<EntityObject<T>>): Promise<T>;
-    with(...relations: (KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this> | [
-        KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this>,
-        RelationsTreeQuery
-    ])[]): this;
-    withCount<K extends KeysOfType<T, List<Entity>>>(...relations: (KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this> | [
-        KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this>,
-        RelationsTreeQuery
-    ])[]): this;
-    private tree;
-    private treeBack;
-}
+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 { RelationsTreeQuery } from './Types';
+export declare class EntityQuery<T extends Entity> extends Query<T> {
+    entity: EntityConstructor<T>;
+    eagerLoad: (string | [string, RelationsTreeQuery])[];
+    eagerLoadCount: (string | [string, RelationsTreeQuery])[];
+    constructor(entity: EntityConstructor<T>);
+    get<K extends keyof T>(...columns: (K | string | StringExpression)[]): Promise<T[]>;
+    eagerLoadRelationships(entities: T[]): Promise<T[]>;
+    eagerLoadRelationshipsCounts(entities: T[]): Promise<T[]>;
+    first<K extends keyof T>(...columns: (K | string | StringExpression)[]): Promise<T | undefined>;
+    firstOrNew<K extends keyof T>(properties: Partial<EntityObject<T> | Record<string, any>>, values?: Partial<EntityObject<T>>): Promise<T>;
+    with(...relations: (KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this> | [
+        KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this>,
+        RelationsTreeQuery
+    ])[]): this;
+    withCount<K extends KeysOfType<T, List<Entity>>>(...relations: (KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this> | [
+        KeysOfType<T, BelongsTo<any> | HasOne<any> | HasMany<any> | BelongsToMany<any>> | DotNotationProperties<this>,
+        RelationsTreeQuery
+    ])[]): this;
+    private tree;
+    private treeBack;
+}
 //# sourceMappingURL=EntityQuery.d.ts.map

package/Database/EntityQuery.js

@@ -1,157 +1,157 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityQuery = void 0;
-const Query_1 = require("./Query");
-const Entity_1 = require("./Entity");
-class EntityQuery extends Query_1.Query {
-    constructor(entity) {
-        super();
-        this.entity = entity;
-        // tslint:disable-next-line:no-any
-        this.eagerLoad = [];
-        // tslint:disable-next-line:no-any
-        this.eagerLoadCount = [];
-    }
-    async get(...columns) {
-        let entities = await super.get(...columns);
-        entities = this.entity.hydrate(this.entity, entities, true);
-        entities = await this.eagerLoadRelationships(entities);
-        return await this.eagerLoadRelationshipsCounts(entities);
-    }
-    async eagerLoadRelationships(entities) {
-        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;
-            let otherRelations = [];
-            if (relationValue instanceof Function) {
-                fieldQueryFunction = relationValue;
-            }
-            else {
-                otherRelations = this.treeBack(relationValue);
-            }
-            const results = await relation.getRelatedValue(entities, otherRelations, fieldQueryFunction);
-            if (results.length) {
-                entities = relation.match(entities, results);
-            }
-        });
-        // 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;
-    }
-    async eagerLoadRelationshipsCounts(entities) {
-        await this.eagerLoadCount.forEachAsync(async (field) => {
-            // tslint:disable-next-line:no-any
-            let fieldName, fieldQueryFunction;
-            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);
-            if (results.length) {
-                entities = relation.matchCounts(entities, results);
-            }
-        });
-        return entities;
-    }
-    async first(...columns) {
-        const entityData = await super.first(...columns);
-        if (!entityData) {
-            return undefined;
-        }
-        let entity = this.entity.new(entityData, true);
-        entity = (await this.eagerLoadRelationships([entity])).first();
-        return (await this.eagerLoadRelationshipsCounts([entity])).first();
-    }
-    async firstOrNew(
-    // tslint:disable-next-line:no-any
-    properties, values) {
-        Object.entries(properties).forEach(([property, value]) => {
-            const field = this.entity.metadata.columns[property] || this.entity.metadata.relationships[property];
-            const finalValue = value instanceof Entity_1.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) {
-        relations = relations.filter(Boolean);
-        if (relations.length) {
-            // tslint:disable-next-line:no-any
-            this.eagerLoad = this.eagerLoad.concat(relations).unique();
-        }
-        return this;
-    }
-    withCount(...relations) {
-        // @ts-ignore
-        this.eagerLoadCount = this.eagerLoadCount.concat(relations);
-        return this;
-    }
-    tree(relations) {
-        const tree = {};
-        relations.forEach(relation => {
-            let relationName;
-            let relationValue = {};
-            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;
-    }
-    treeBack(relationsTree) {
-        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('.');
-            }
-        });
-    }
-}
-exports.EntityQuery = EntityQuery;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityQuery = void 0;
+const Query_1 = require("./Query");
+const Entity_1 = require("./Entity");
+class EntityQuery extends Query_1.Query {
+    constructor(entity) {
+        super();
+        this.entity = entity;
+        // tslint:disable-next-line:no-any
+        this.eagerLoad = [];
+        // tslint:disable-next-line:no-any
+        this.eagerLoadCount = [];
+    }
+    async get(...columns) {
+        let entities = await super.get(...columns);
+        entities = this.entity.hydrate(this.entity, entities, true);
+        entities = await this.eagerLoadRelationships(entities);
+        return await this.eagerLoadRelationshipsCounts(entities);
+    }
+    async eagerLoadRelationships(entities) {
+        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;
+            let otherRelations = [];
+            if (relationValue instanceof Function) {
+                fieldQueryFunction = relationValue;
+            }
+            else {
+                otherRelations = this.treeBack(relationValue);
+            }
+            const results = await relation.getRelatedValue(entities, otherRelations, fieldQueryFunction);
+            if (results.length) {
+                entities = relation.match(entities, results);
+            }
+        });
+        // 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;
+    }
+    async eagerLoadRelationshipsCounts(entities) {
+        await this.eagerLoadCount.forEachAsync(async (field) => {
+            // tslint:disable-next-line:no-any
+            let fieldName, fieldQueryFunction;
+            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);
+            if (results.length) {
+                entities = relation.matchCounts(entities, results);
+            }
+        });
+        return entities;
+    }
+    async first(...columns) {
+        const entityData = await super.first(...columns);
+        if (!entityData) {
+            return undefined;
+        }
+        let entity = this.entity.new(entityData, true);
+        entity = (await this.eagerLoadRelationships([entity])).first();
+        return (await this.eagerLoadRelationshipsCounts([entity])).first();
+    }
+    async firstOrNew(
+    // tslint:disable-next-line:no-any
+    properties, values) {
+        Object.entries(properties).forEach(([property, value]) => {
+            const field = this.entity.metadata.columns[property] || this.entity.metadata.relationships[property];
+            const finalValue = value instanceof Entity_1.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) {
+        relations = relations.filter(Boolean);
+        if (relations.length) {
+            // tslint:disable-next-line:no-any
+            this.eagerLoad = this.eagerLoad.concat(relations).unique();
+        }
+        return this;
+    }
+    withCount(...relations) {
+        // @ts-ignore
+        this.eagerLoadCount = this.eagerLoadCount.concat(relations);
+        return this;
+    }
+    tree(relations) {
+        const tree = {};
+        relations.forEach(relation => {
+            let relationName;
+            let relationValue = {};
+            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;
+    }
+    treeBack(relationsTree) {
+        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('.');
+            }
+        });
+    }
+}
+exports.EntityQuery = EntityQuery;
 //# sourceMappingURL=EntityQuery.js.map

package/Database/Expression.d.ts

@@ -1,4 +1,4 @@
-export declare abstract class Expression {
-    abstract toSQL(): string;
-}
+export declare abstract class Expression {
+    abstract toSQL(): string;
+}
 //# sourceMappingURL=Expression.d.ts.map

package/Database/Expression.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Expression = void 0;
-class Expression {
-}
-exports.Expression = Expression;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Expression = void 0;
+class Expression {
+}
+exports.Expression = Expression;
 //# sourceMappingURL=Expression.js.map