@typetron/framework 0.3.17 → 0.4.0-rc1

package/Database/Fields.js

@@ -1,549 +1,545 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BelongsToMany = exports.HasMany = exports.HasOne = exports.BelongsTo = exports.BelongsToManyField = exports.BelongsToField = exports.HasManyField = exports.HasOneField = exports.InverseRelationship = exports.RelationshipField = exports.PrimaryField = exports.InverseField = exports.JSONField = exports.ColumnField = void 0;
-const Entity_1 = require("./Entity");
-const index_1 = require("./index");
-const List_1 = require("./List");
-const BaseRelationship_1 = require("./ORM/BaseRelationship");
-const Helpers_1 = require("./Helpers");
-class ColumnField {
-    constructor(entity, property, type, column) {
-        this.entity = entity;
-        this.property = property;
-        this.type = type;
-        this.column = column;
-    }
-    value(entity, key) {
-        return entity[key];
-    }
-    set(target, value) {
-        target[this.property] = value;
-    }
-}
-exports.ColumnField = ColumnField;
-class JSONField extends ColumnField {
-    value(entity, key) {
-        return JSON.stringify(entity[key]);
-    }
-    set(target, value) {
-        target[this.property] = typeof value === 'string' ? JSON.parse(value) : undefined;
-    }
-}
-exports.JSONField = JSONField;
-class InverseField {
-    constructor(entity, property, type) {
-        this.entity = entity;
-        this.property = property;
-        this.type = type;
-    }
-    value(entity, key) {
-        return entity[key];
-    }
-}
-exports.InverseField = InverseField;
-class PrimaryField extends ColumnField {
-}
-exports.PrimaryField = PrimaryField;
-class RelationshipField extends ColumnField {
-    constructor(entity, property, type, inverseBy, column) {
-        super(entity, property, type, column);
-        this.type = type;
-        this.inverseBy = inverseBy;
-    }
-    get related() {
-        return this.type();
-    }
-}
-exports.RelationshipField = RelationshipField;
-class InverseRelationship extends InverseField {
-    constructor(entity, property, type, inverseBy) {
-        super(entity, property, type);
-        this.type = type;
-        this.inverseBy = inverseBy;
-    }
-    get related() {
-        return this.type();
-    }
-}
-exports.InverseRelationship = InverseRelationship;
-class HasOneField extends InverseRelationship {
-    constructor(entity, property, type, inverseBy // TODO make it key of R
-    ) {
-        super(entity, property, type, inverseBy);
-        this.relationClass = HasOne;
-    }
-    set(target, value) {
-        target[this.property].set(value);
-    }
-    async getRelatedValue(relatedEntities, eagerLoad, customQuery) {
-        const parentIds = relatedEntities.pluck(this.entity.getPrimaryKey());
-        const inverseByField = this.related.metadata.relationships[this.inverseBy];
-        const query = this.related.with(...eagerLoad).whereIn(inverseByField.column, parentIds);
-        customQuery === null || customQuery === void 0 ? void 0 : customQuery(query);
-        return await query.get();
-    }
-    async getRelatedCount(relatedEntities, customQuery) {
-        const relatedField = this.related.metadata.relationships[this.inverseBy];
-        const query = this.related.newQuery()
-            .whereIn(relatedField.column, relatedEntities.pluck(this.entity.getPrimaryKey()))
-            .select(relatedField.column)
-            .groupBy(relatedField.column);
-        customQuery === null || customQuery === void 0 ? void 0 : customQuery(query);
-        return await query
-            .selectCount()
-            .get();
-    }
-    match(entities, relatedEntities) {
-        entities.forEach(entity => {
-            const inverseField = this.related.metadata.relationships[this.inverseBy];
-            const relatedEntity = relatedEntities.find(related => related.original[inverseField.column] === entity[this.entity.getPrimaryKey()]);
-            // TODO fix these weird types. Get rid of `unknown`
-            entity[this.property].set(relatedEntity);
-        });
-        return entities;
-    }
-    matchCounts(entities, counts) {
-        const relatedField = this.related.metadata.relationships[this.inverseBy];
-        entities.forEach(entity => {
-            var _a;
-            const count = counts.find(item => item.original[relatedField.column] === entity[this.entity.getPrimaryKey()]);
-            entity[this.property + 'Count'] = ((_a = count === null || count === void 0 ? void 0 : count.original.aggregate) !== null && _a !== void 0 ? _a : 0);
-        });
-        return entities;
-    }
-}
-exports.HasOneField = HasOneField;
-class HasManyField extends InverseRelationship {
-    constructor(entity, property, type, inverseBy) {
-        super(entity, property, type, inverseBy);
-        this.inverseBy = inverseBy;
-        this.relationClass = HasMany;
-    }
-    set(target, value) {
-    }
-    async getRelatedValue(relatedEntities, eagerLoad, customQuery) {
-        const parentIds = relatedEntities.pluck(this.entity.getPrimaryKey());
-        const inverseByField = this.related.metadata.relationships[this.inverseBy];
-        const query = this.related.with(...eagerLoad).whereIn(inverseByField.column, parentIds);
-        customQuery === null || customQuery === void 0 ? void 0 : customQuery(query);
-        return await query.get();
-    }
-    async getRelatedCount(relatedEntities, customQuery) {
-        const relatedField = this.related.metadata.relationships[this.inverseBy];
-        const query = this.related.newQuery()
-            .whereIn(relatedField.column, relatedEntities.pluck(this.entity.getPrimaryKey()))
-            .select(relatedField.column)
-            .groupBy(relatedField.column);
-        customQuery === null || customQuery === void 0 ? void 0 : customQuery(query);
-        return await query
-            .selectCount()
-            .get();
-    }
-    match(entities, relatedEntities) {
-        entities.forEach(entity => {
-            const inverseField = this.related.metadata.relationships[this.inverseBy];
-            const relatedEntity = relatedEntities.filter(related => related.original[inverseField.column] === entity[this.entity.getPrimaryKey()]);
-            // TODO fix these weird types. Get rid of `unknown`
-            entity[this.property].items = relatedEntity;
-        });
-        return entities;
-    }
-    matchCounts(entities, counts) {
-        const relatedField = this.related.metadata.relationships[this.inverseBy];
-        entities.forEach(entity => {
-            var _a;
-            const count = counts.find(item => item.original[relatedField.column] === entity[this.entity.getPrimaryKey()]);
-            entity[this.property + 'Count'] = ((_a = count === null || count === void 0 ? void 0 : count.original.aggregate) !== null && _a !== void 0 ? _a : 0);
-        });
-        return entities;
-    }
-    async save(items, parent) {
-        const entities = [];
-        for await (const item of items) {
-            const entity = item instanceof Entity_1.Entity ? item : this.type().new(item);
-            entity.fill({
-                [this.inverseBy]: parent
-            });
-            await entity.save();
-            entities.push(entity);
-        }
-        return entities;
-    }
-    getQuery(parent) {
-        const inverseField = this.related.metadata.relationships[this.inverseBy];
-        return this.type().newQuery().where(inverseField.column, parent[parent.getPrimaryKey()]);
-    }
-}
-exports.HasManyField = HasManyField;
-class BelongsToField extends RelationshipField {
-    constructor(entity, property, type, inverseBy, column) {
-        super(entity, property, type, inverseBy, column || property + entity.getPrimaryKey().capitalize());
-        this.relationClass = BelongsTo;
-    }
-    set(target, value) {
-        target[this.property].set(value);
-    }
-    update(target) {
-        target[this.property].update();
-    }
-    value(entity, key) {
-        const field = entity[key];
-        const instance = field.get();
-        if (instance) {
-            return instance[this.related.getPrimaryKey()];
-        }
-        // return new this.related({
-        //     [this.related.getPrimaryKey()]: entity[key as K]
-        // }) as unknown as T[K]; // TODO get rid of `unknown`
-        // if (key === this.column) {
-        //     return new this.related({
-        //         [this.related.getPrimaryKey()]: entity[key as K]
-        //     }) as unknown as T[K]; // TODO get rid of `unknown`
-        // }
-        // return entity[this.property as keyof T] as unknown as T[K];
-    }
-    async getRelatedValue(parents, eagerLoad, customQuery) {
-        const relationIds = parents
-            .map(parent => {
-            const relation = parent[this.property].get();
-            return relation === null || relation === void 0 ? void 0 : relation[relation.getPrimaryKey()];
-        })
-            .filter(Boolean);
-        if (relationIds.length) {
-            const query = this.related.with(...eagerLoad).whereIn(this.related.getPrimaryKey(), relationIds);
-            if (customQuery) {
-                customQuery(query);
-            }
-            return await query.get();
-        }
-        return [];
-    }
-    async getRelatedCount(relatedEntities, customQuery) {
-        return [];
-    }
-    match(entities, relatedEntities) {
-        return entities.map(entity => {
-            // TODO fix these weird types. Get rid of `unknown`
-            const related = entity[this.property].get();
-            const value = related === null || related === void 0 ? void 0 : related[related.getPrimaryKey()];
-            if (value) {
-                const instance = relatedEntities.findWhere(this.related.getPrimaryKey(), value);
-                if (instance) {
-                    this.set(entity, instance);
-                }
-            }
-            return entity;
-        });
-    }
-    matchCounts(entities, counts) {
-        return entities;
-    }
-    getQuery(parent) {
-        return this.entity.newQuery().where(this.column, parent[parent.getPrimaryKey()]);
-    }
-    async save(items, parent) {
-        const entities = [];
-        for await (const item of items) {
-            const entity = item instanceof Entity_1.Entity ? item : this.entity.new(item);
-            entity.fill({
-                [this.property]: parent
-            });
-            await entity.save();
-            entities.push(entity);
-        }
-        return entities;
-    }
-}
-exports.BelongsToField = BelongsToField;
-class BelongsToManyField extends InverseRelationship {
-    constructor(entity, property, type, inverseBy, table, parentColumn, relatedColumn) {
-        super(entity, property, type, inverseBy);
-        this.table = table;
-        this.parentColumn = parentColumn;
-        this.relatedColumn = relatedColumn;
-        this.relationClass = BelongsToMany;
-    }
-    set(target, value) {
-    }
-    async getRelatedValue(parents, eagerLoad, customQuery) {
-        const parentIds = parents.pluck(this.entity.getPrimaryKey());
-        const relatedForeignKey = `${Helpers_1.wrap(this.getPivotTable())}.${this.getRelatedForeignKey()}`;
-        const parentForeignKey = `${Helpers_1.wrap(this.getPivotTable())}.${this.getParentForeignKey()}`;
-        const relatedKey = `${Helpers_1.wrap(this.related.getTable())}.${this.related.getPrimaryKey()}`;
-        const query = this.related
-            .with(...eagerLoad)
-            .addSelect(new index_1.StringExpression(`${Helpers_1.wrap(this.related.getTable())}.*`), new index_1.StringExpression(relatedForeignKey), new index_1.StringExpression(parentForeignKey))
-            .join(this.getPivotTable(), relatedForeignKey, '=', relatedKey)
-            .whereIn(parentForeignKey, parentIds.unique());
-        customQuery === null || customQuery === void 0 ? void 0 : customQuery(query);
-        const results = await query.get();
-        return results.map(entity => {
-            entity.original.pivot = {
-                [this.getParentForeignKey()]: entity.original[this.getParentForeignKey()],
-                [this.getRelatedForeignKey()]: entity.original[this.getRelatedForeignKey()],
-            };
-            delete entity.original[this.getParentForeignKey()];
-            delete entity.original[this.getRelatedForeignKey()];
-            return entity;
-        });
-    }
-    getParentForeignKey() {
-        return this.parentColumn || `${this.entity.name.toLocaleLowerCase()}${this.entity.getPrimaryKey().capitalize()}`;
-    }
-    getRelatedForeignKey() {
-        return this.relatedColumn || `${this.related.name.toLocaleLowerCase()}${this.related.getPrimaryKey().capitalize()}`;
-    }
-    async getRelatedCount(relatedEntities, customQuery) {
-        const query = index_1.Query.table(this.getPivotTable())
-            .select(this.getParentForeignKey())
-            .groupBy(this.getParentForeignKey())
-            .whereIn(this.getParentForeignKey(), relatedEntities.pluck(this.related.getPrimaryKey()));
-        customQuery === null || customQuery === void 0 ? void 0 : customQuery(query);
-        return await query.selectCount().get();
-    }
-    match(entities, relatedEntities) {
-        return entities.map(entity => {
-            const entityPrimaryKey = entity[this.entity.getPrimaryKey()];
-            entity[this.property].items = relatedEntities
-                .filter(related => related.original.pivot[this.getParentForeignKey()] === entityPrimaryKey);
-            return entity;
-        });
-    }
-    matchCounts(entities, counts) {
-        entities.forEach(entity => {
-            const foreignKey = this.getParentForeignKey();
-            const count = counts.find(item => { var _a; return (((_a = item === null || item === void 0 ? void 0 : item.original) === null || _a === void 0 ? void 0 : _a[foreignKey]) || item[foreignKey]) === entity[this.entity.getPrimaryKey()]; });
-            // @ts-ignore
-            const aggregateValue = (count === null || count === void 0 ? void 0 : count.aggregate) || (count === null || count === void 0 ? void 0 : count.original.aggregate);
-            entity[this.property + 'Count'] = (aggregateValue !== null && aggregateValue !== void 0 ? aggregateValue : 0);
-        });
-        return entities;
-    }
-    getPivotTable() {
-        return this.table || [this.entity.getTable(), this.related.getTable()].sort().join('_');
-    }
-    value(entity, key) {
-        const value = entity[key];
-        if (value instanceof Array) {
-            return value.map(related => {
-                if (related instanceof Entity_1.Entity) {
-                    return related;
-                }
-                const instance = new this.related();
-                instance[instance.getPrimaryKey()] = related;
-                return instance;
-            });
-        }
-        return value;
-    }
-    async add(items, parent) {
-        const entities = [];
-        // tslint:disable-next-line:no-any
-        const dataToInsert = [];
-        for await (const item of items) {
-            dataToInsert.push({
-                [this.getRelatedForeignKey()]: item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item,
-                [this.getParentForeignKey()]: parent.getPrimaryKeyValue(),
-            });
-            entities.push(this.related.new({ [this.related.getPrimaryKey()]: item }));
-        }
-        if (dataToInsert.length) {
-            await index_1.Query.table(this.getPivotTable()).insert(dataToInsert);
-        }
-        return entities;
-    }
-    getQuery(parent) {
-        return this.related.newQuery().whereIn(this.related.getPrimaryKey(), query => {
-            query.select(this.getRelatedForeignKey())
-                .table(this.getPivotTable())
-                .where(this.getParentForeignKey(), parent[parent.getPrimaryKey()]);
-        });
-    }
-}
-exports.BelongsToManyField = BelongsToManyField;
-class BelongsTo extends BaseRelationship_1.BaseRelationship {
-    constructor(relationship, parent) {
-        super(relationship, parent);
-        this.update();
-    }
-    update() {
-        const parentId = this.parent.original[this.relationship.column];
-        if (parentId && !this.instance) {
-            this.setById(parentId);
-        }
-    }
-    static relationship(metadata, entityClass, property, type, inverseBy, options) {
-        metadata.relationships[property] = new BelongsToField(entityClass, property, type, inverseBy, options === null || options === void 0 ? void 0 : options.column);
-        return metadata;
-    }
-    get() {
-        return this.instance;
-    }
-    set(instance) {
-        if (instance instanceof Entity_1.Entity) {
-            this.instance = instance;
-        }
-        else {
-            this.setById(instance);
-        }
-    }
-    setById(id) {
-        this.set(this.relationship.related.new({ [this.relationship.related.getPrimaryKey()]: id }));
-    }
-    async save(data = {}) {
-        if (!this.instance) {
-            return;
-        }
-        this.instance.fill({
-            ...data,
-        });
-        await this.instance.save();
-        return this.instance;
-    }
-    toJSON() {
-        var _a;
-        return (_a = this.instance) === null || _a === void 0 ? void 0 : _a.toJSON();
-    }
-}
-exports.BelongsTo = BelongsTo;
-class HasOne extends BaseRelationship_1.BaseRelationship {
-    static relationship(metadata, entityClass, property, type, inverseBy, options) {
-        metadata.inverseRelationships[property] = new HasOneField(entityClass, property, type, inverseBy);
-        return metadata;
-    }
-    get() {
-        return this.instance;
-    }
-    set(instance) {
-        if (!instance) {
-            return;
-        }
-        if (instance instanceof Entity_1.Entity) {
-            this.instance = instance;
-        }
-        else {
-            this.setById(instance);
-        }
-    }
-    setById(id) {
-        this.set(this.relationship.related.new({ [this.relationship.related.getPrimaryKey()]: id }));
-    }
-    async save(instance = this.instance) {
-        this.set(instance);
-        if (instance) {
-            instance[this.relationship.inverseBy].set(this.parent);
-            await instance.save();
-        }
-        return this.instance;
-    }
-    toJSON() {
-        var _a;
-        return (_a = this.instance) === null || _a === void 0 ? void 0 : _a.toJSON();
-    }
-}
-exports.HasOne = HasOne;
-class HasMany extends List_1.List {
-    constructor(relationship, parent) {
-        super(relationship, parent);
-        this.relationship = relationship;
-    }
-    static relationship(metadata, entityClass, property, type, inverseBy, options) {
-        metadata.inverseRelationships[property] = new HasManyField(entityClass, property, type, inverseBy);
-        return metadata;
-    }
-    async save(item) {
-        const instances = await this.saveMany(item);
-        return instances.first();
-    }
-    async saveMany(...items) {
-        if (!this.parent.exists) {
-            await this.parent.save();
-        }
-        const instances = await this.relationship.save(items, this.parent);
-        this.items.push(...instances);
-        return instances;
-    }
-    async clear() {
-    }
-}
-exports.HasMany = HasMany;
-class BelongsToMany extends List_1.List {
-    constructor(relationship, parent) {
-        super(relationship, parent);
-        this.relationship = relationship;
-    }
-    static relationship(metadata, entityClass, property, type, inverseBy, options) {
-        // options.column = options.column || (property as string) + (entityClass.getPrimaryKey() as string).capitalize();
-        const inverseField = metadata.inverseRelationships[inverseBy];
-        metadata.inverseRelationships[property] = new BelongsToManyField(entityClass, property, type, inverseBy, (options === null || options === void 0 ? void 0 : options.table) || (inverseField === null || inverseField === void 0 ? void 0 : inverseField.table), (options === null || options === void 0 ? void 0 : options.foreignColumn) || (inverseField === null || inverseField === void 0 ? void 0 : inverseField.parentColumn), (options === null || options === void 0 ? void 0 : options.column) || (inverseField === null || inverseField === void 0 ? void 0 : inverseField.relatedColumn));
-        return metadata;
-    }
-    async has(item) {
-        if (item instanceof Entity_1.Entity) {
-            item = item.getPrimaryKeyValue();
-        }
-        const relatedForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getRelatedForeignKey()}`;
-        const parentForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getParentForeignKey()}`;
-        return Boolean(await index_1.Query.table(this.relationship.getPivotTable())
-            .where(parentForeignKey, this.parent[this.parent.getPrimaryKey()])
-            .andWhere(relatedForeignKey, item)
-            .first());
-    }
-    async add(...items) {
-        const ids = items.map(item => item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item);
-        if (!this.parent.exists) {
-            await this.parent.save();
-        }
-        for await (const id of ids) {
-            if (!(await this.has(id))) {
-                this.items = this.items.concat(await this.relationship.add(items, this.parent));
-            }
-        }
-        return this.items;
-    }
-    async remove(...items) {
-        const ids = items.map(item => item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item);
-        const relatedForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getRelatedForeignKey()}`;
-        const parentForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getParentForeignKey()}`;
-        await index_1.Query.table(this.relationship.getPivotTable())
-            .where(parentForeignKey, this.parent[this.parent.getPrimaryKey()])
-            .whereIn(relatedForeignKey, ids)
-            .delete();
-        this.items = this.items.filter(item => !ids.includes(item.getPrimaryKeyValue()));
-    }
-    async toggle(...items) {
-        const ids = items.map(item => item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item);
-        const attachedEntities = await this.relationship.getQuery(this.parent).get();
-        const entitiesToDetach = ids.filter(item => attachedEntities.some(entity => entity.getPrimaryKeyValue() === item));
-        const entitiesToAttach = ids.filter(item => attachedEntities.some(entity => entity.getPrimaryKeyValue() !== item));
-        await this.add(...entitiesToAttach);
-        await this.remove(...entitiesToDetach);
-    }
-    async clear() {
-        const relatedForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getRelatedForeignKey()}`;
-        const parentForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getParentForeignKey()}`;
-        await index_1.Query.table(this.relationship.getPivotTable())
-            .where(parentForeignKey, this.parent[this.parent.getPrimaryKey()])
-            .whereIn(relatedForeignKey, this.items.pluck(this.relationship.related.getPrimaryKey()))
-            .delete();
-        this.items = [];
-    }
-    async sync(...items) {
-        const ids = items.map(item => item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item);
-        const existingItems = await this.get();
-        const primaryKey = this.relationship.type().getPrimaryKey();
-        const itemsToRemove = existingItems.filter(item => !ids.includes(item[primaryKey])).pluck(primaryKey);
-        const restOfItemsToAdd = ids.filter(item => !existingItems.findWhere(primaryKey, item));
-        await this.remove(...itemsToRemove);
-        await this.add(...restOfItemsToAdd);
-    }
-    async syncWithoutDetaching(...items) {
-        const ids = items.map(item => item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item);
-        const existingItems = await this.get();
-        const primaryKey = this.relationship.type().getPrimaryKey();
-        const restOfItemsToAdd = ids.filter(item => !existingItems.findWhere(primaryKey, item));
-        await this.add(...restOfItemsToAdd);
-    }
-}
-exports.BelongsToMany = BelongsToMany;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsToMany = exports.HasMany = exports.HasOne = exports.BelongsTo = exports.BelongsToManyField = exports.BelongsToField = exports.HasManyField = exports.HasOneField = exports.InverseRelationship = exports.RelationshipField = exports.PrimaryField = exports.InverseField = exports.JSONField = exports.ColumnField = void 0;
+const Entity_1 = require("./Entity");
+const index_1 = require("./index");
+const List_1 = require("./List");
+const BaseRelationship_1 = require("./ORM/BaseRelationship");
+const Helpers_1 = require("./Helpers");
+class ColumnField {
+    constructor(entity, property, type, column) {
+        this.entity = entity;
+        this.property = property;
+        this.type = type;
+        this.column = column;
+    }
+    value(entity, key) {
+        return entity[key];
+    }
+    set(target, value) {
+        target[this.property] = value;
+    }
+}
+exports.ColumnField = ColumnField;
+class JSONField extends ColumnField {
+    value(entity, key) {
+        return JSON.stringify(entity[key]);
+    }
+    set(target, value) {
+        target[this.property] = typeof value === 'string' ? JSON.parse(value) : undefined;
+    }
+}
+exports.JSONField = JSONField;
+class InverseField {
+    constructor(entity, property, type) {
+        this.entity = entity;
+        this.property = property;
+        this.type = type;
+    }
+    value(entity, key) {
+        return entity[key];
+    }
+}
+exports.InverseField = InverseField;
+class PrimaryField extends ColumnField {
+}
+exports.PrimaryField = PrimaryField;
+class RelationshipField extends ColumnField {
+    constructor(entity, property, type, inverseBy, column) {
+        super(entity, property, type, column);
+        this.type = type;
+        this.inverseBy = inverseBy;
+    }
+    get related() {
+        return this.type();
+    }
+}
+exports.RelationshipField = RelationshipField;
+class InverseRelationship extends InverseField {
+    constructor(entity, property, type, inverseBy) {
+        super(entity, property, type);
+        this.type = type;
+        this.inverseBy = inverseBy;
+    }
+    get related() {
+        return this.type();
+    }
+}
+exports.InverseRelationship = InverseRelationship;
+class HasOneField extends InverseRelationship {
+    constructor(entity, property, type, inverseBy // TODO make it key of R
+    ) {
+        super(entity, property, type, inverseBy);
+        this.relationClass = HasOne;
+    }
+    set(target, value) {
+        target[this.property].set(value);
+    }
+    async getRelatedValue(relatedEntities, eagerLoad, customQuery) {
+        const parentIds = relatedEntities.pluck(this.entity.getPrimaryKey());
+        const inverseByField = this.related.metadata.relationships[this.inverseBy];
+        const query = this.related.with(...eagerLoad).whereIn(inverseByField.column, parentIds);
+        customQuery?.(query);
+        return await query.get();
+    }
+    async getRelatedCount(relatedEntities, customQuery) {
+        const relatedField = this.related.metadata.relationships[this.inverseBy];
+        const query = this.related.newQuery()
+            .whereIn(relatedField.column, relatedEntities.pluck(this.entity.getPrimaryKey()))
+            .select(relatedField.column)
+            .groupBy(relatedField.column);
+        customQuery?.(query);
+        return await query
+            .selectCount()
+            .get();
+    }
+    match(entities, relatedEntities) {
+        entities.forEach(entity => {
+            const inverseField = this.related.metadata.relationships[this.inverseBy];
+            const relatedEntity = relatedEntities.find(related => related.original[inverseField.column] === entity[this.entity.getPrimaryKey()]);
+            // TODO fix these weird types. Get rid of `unknown`
+            entity[this.property].set(relatedEntity);
+        });
+        return entities;
+    }
+    matchCounts(entities, counts) {
+        const relatedField = this.related.metadata.relationships[this.inverseBy];
+        entities.forEach(entity => {
+            const count = counts.find(item => item.original[relatedField.column] === entity[this.entity.getPrimaryKey()]);
+            entity[this.property + 'Count'] = (count?.original.aggregate ?? 0);
+        });
+        return entities;
+    }
+}
+exports.HasOneField = HasOneField;
+class HasManyField extends InverseRelationship {
+    constructor(entity, property, type, inverseBy) {
+        super(entity, property, type, inverseBy);
+        this.inverseBy = inverseBy;
+        this.relationClass = HasMany;
+    }
+    set(target, value) {
+    }
+    async getRelatedValue(relatedEntities, eagerLoad, customQuery) {
+        const parentIds = relatedEntities.pluck(this.entity.getPrimaryKey());
+        const inverseByField = this.related.metadata.relationships[this.inverseBy];
+        const query = this.related.with(...eagerLoad).whereIn(inverseByField.column, parentIds);
+        customQuery?.(query);
+        return await query.get();
+    }
+    async getRelatedCount(relatedEntities, customQuery) {
+        const relatedField = this.related.metadata.relationships[this.inverseBy];
+        const query = this.related.newQuery()
+            .whereIn(relatedField.column, relatedEntities.pluck(this.entity.getPrimaryKey()))
+            .select(relatedField.column)
+            .groupBy(relatedField.column);
+        customQuery?.(query);
+        return await query
+            .selectCount()
+            .get();
+    }
+    match(entities, relatedEntities) {
+        entities.forEach(entity => {
+            const inverseField = this.related.metadata.relationships[this.inverseBy];
+            const relatedEntity = relatedEntities.filter(related => related.original[inverseField.column] === entity[this.entity.getPrimaryKey()]);
+            // TODO fix these weird types. Get rid of `unknown`
+            entity[this.property].items = relatedEntity;
+        });
+        return entities;
+    }
+    matchCounts(entities, counts) {
+        const relatedField = this.related.metadata.relationships[this.inverseBy];
+        entities.forEach(entity => {
+            const count = counts.find(item => item.original[relatedField.column] === entity[this.entity.getPrimaryKey()]);
+            entity[this.property + 'Count'] = (count?.original.aggregate ?? 0);
+        });
+        return entities;
+    }
+    async save(items, parent) {
+        const entities = [];
+        for await (const item of items) {
+            const entity = item instanceof Entity_1.Entity ? item : this.type().new(item);
+            entity.fill({
+                [this.inverseBy]: parent
+            });
+            await entity.save();
+            entities.push(entity);
+        }
+        return entities;
+    }
+    getQuery(parent) {
+        const inverseField = this.related.metadata.relationships[this.inverseBy];
+        return this.type().newQuery().where(inverseField.column, parent[parent.getPrimaryKey()]);
+    }
+}
+exports.HasManyField = HasManyField;
+class BelongsToField extends RelationshipField {
+    constructor(entity, property, type, inverseBy, column) {
+        super(entity, property, type, inverseBy, column || property + entity.getPrimaryKey().capitalize());
+        this.relationClass = BelongsTo;
+    }
+    set(target, value) {
+        target[this.property].set(value);
+    }
+    update(target) {
+        target[this.property].update();
+    }
+    value(entity, key) {
+        const field = entity[key];
+        const instance = field.get();
+        if (instance) {
+            return instance[this.related.getPrimaryKey()];
+        }
+        // return new this.related({
+        //     [this.related.getPrimaryKey()]: entity[key as K]
+        // }) as unknown as T[K]; // TODO get rid of `unknown`
+        // if (key === this.column) {
+        //     return new this.related({
+        //         [this.related.getPrimaryKey()]: entity[key as K]
+        //     }) as unknown as T[K]; // TODO get rid of `unknown`
+        // }
+        // return entity[this.property as keyof T] as unknown as T[K];
+    }
+    async getRelatedValue(parents, eagerLoad, customQuery) {
+        const relationIds = parents
+            .map(parent => {
+            const relation = parent[this.property].get();
+            return relation?.[relation.getPrimaryKey()];
+        })
+            .filter(Boolean);
+        if (relationIds.length) {
+            const query = this.related.with(...eagerLoad).whereIn(this.related.getPrimaryKey(), relationIds);
+            if (customQuery) {
+                customQuery(query);
+            }
+            return await query.get();
+        }
+        return [];
+    }
+    async getRelatedCount(relatedEntities, customQuery) {
+        return [];
+    }
+    match(entities, relatedEntities) {
+        return entities.map(entity => {
+            // TODO fix these weird types. Get rid of `unknown`
+            const related = entity[this.property].get();
+            const value = related?.[related.getPrimaryKey()];
+            if (value) {
+                const instance = relatedEntities.findWhere(this.related.getPrimaryKey(), value);
+                if (instance) {
+                    this.set(entity, instance);
+                }
+            }
+            return entity;
+        });
+    }
+    matchCounts(entities, counts) {
+        return entities;
+    }
+    getQuery(parent) {
+        return this.entity.newQuery().where(this.column, parent[parent.getPrimaryKey()]);
+    }
+    async save(items, parent) {
+        const entities = [];
+        for await (const item of items) {
+            const entity = item instanceof Entity_1.Entity ? item : this.entity.new(item);
+            entity.fill({
+                [this.property]: parent
+            });
+            await entity.save();
+            entities.push(entity);
+        }
+        return entities;
+    }
+}
+exports.BelongsToField = BelongsToField;
+class BelongsToManyField extends InverseRelationship {
+    constructor(entity, property, type, inverseBy, table, parentColumn, relatedColumn) {
+        super(entity, property, type, inverseBy);
+        this.table = table;
+        this.parentColumn = parentColumn;
+        this.relatedColumn = relatedColumn;
+        this.relationClass = BelongsToMany;
+    }
+    set(target, value) {
+    }
+    async getRelatedValue(parents, eagerLoad, customQuery) {
+        const parentIds = parents.pluck(this.entity.getPrimaryKey());
+        const relatedForeignKey = `${Helpers_1.wrap(this.getPivotTable())}.${this.getRelatedForeignKey()}`;
+        const parentForeignKey = `${Helpers_1.wrap(this.getPivotTable())}.${this.getParentForeignKey()}`;
+        const relatedKey = `${Helpers_1.wrap(this.related.getTable())}.${this.related.getPrimaryKey()}`;
+        const query = this.related
+            .with(...eagerLoad)
+            .addSelect(new index_1.StringExpression(`${Helpers_1.wrap(this.related.getTable())}.*`), new index_1.StringExpression(relatedForeignKey), new index_1.StringExpression(parentForeignKey))
+            .join(this.getPivotTable(), relatedForeignKey, '=', relatedKey)
+            .whereIn(parentForeignKey, parentIds.unique());
+        customQuery?.(query);
+        const results = await query.get();
+        return results.map(entity => {
+            entity.original.pivot = {
+                [this.getParentForeignKey()]: entity.original[this.getParentForeignKey()],
+                [this.getRelatedForeignKey()]: entity.original[this.getRelatedForeignKey()],
+            };
+            delete entity.original[this.getParentForeignKey()];
+            delete entity.original[this.getRelatedForeignKey()];
+            return entity;
+        });
+    }
+    getParentForeignKey() {
+        return this.parentColumn || `${this.entity.name.toLocaleLowerCase()}${this.entity.getPrimaryKey().capitalize()}`;
+    }
+    getRelatedForeignKey() {
+        return this.relatedColumn || `${this.related.name.toLocaleLowerCase()}${this.related.getPrimaryKey().capitalize()}`;
+    }
+    async getRelatedCount(relatedEntities, customQuery) {
+        const query = index_1.Query.table(this.getPivotTable())
+            .select(this.getParentForeignKey())
+            .groupBy(this.getParentForeignKey())
+            .whereIn(this.getParentForeignKey(), relatedEntities.pluck(this.related.getPrimaryKey()));
+        customQuery?.(query);
+        return await query.selectCount().get();
+    }
+    match(entities, relatedEntities) {
+        return entities.map(entity => {
+            const entityPrimaryKey = entity[this.entity.getPrimaryKey()];
+            entity[this.property].items = relatedEntities
+                .filter(related => related.original.pivot[this.getParentForeignKey()] === entityPrimaryKey);
+            return entity;
+        });
+    }
+    matchCounts(entities, counts) {
+        entities.forEach(entity => {
+            const foreignKey = this.getParentForeignKey();
+            const count = counts.find(item => (item?.original?.[foreignKey] || item[foreignKey]) === entity[this.entity.getPrimaryKey()]);
+            // @ts-ignore
+            const aggregateValue = count?.aggregate || count?.original.aggregate;
+            entity[this.property + 'Count'] = (aggregateValue ?? 0);
+        });
+        return entities;
+    }
+    getPivotTable() {
+        return this.table || [this.entity.getTable(), this.related.getTable()].sort().join('_');
+    }
+    value(entity, key) {
+        const value = entity[key];
+        if (value instanceof Array) {
+            return value.map(related => {
+                if (related instanceof Entity_1.Entity) {
+                    return related;
+                }
+                const instance = new this.related();
+                instance[instance.getPrimaryKey()] = related;
+                return instance;
+            });
+        }
+        return value;
+    }
+    async add(items, parent) {
+        const entities = [];
+        // tslint:disable-next-line:no-any
+        const dataToInsert = [];
+        for await (const item of items) {
+            dataToInsert.push({
+                [this.getRelatedForeignKey()]: item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item,
+                [this.getParentForeignKey()]: parent.getPrimaryKeyValue(),
+            });
+            entities.push(this.related.new({ [this.related.getPrimaryKey()]: item }));
+        }
+        if (dataToInsert.length) {
+            await index_1.Query.table(this.getPivotTable()).insert(dataToInsert);
+        }
+        return entities;
+    }
+    getQuery(parent) {
+        return this.related.newQuery().whereIn(this.related.getPrimaryKey(), query => {
+            query.select(this.getRelatedForeignKey())
+                .table(this.getPivotTable())
+                .where(this.getParentForeignKey(), parent[parent.getPrimaryKey()]);
+        });
+    }
+}
+exports.BelongsToManyField = BelongsToManyField;
+class BelongsTo extends BaseRelationship_1.BaseRelationship {
+    constructor(relationship, parent) {
+        super(relationship, parent);
+        this.update();
+    }
+    update() {
+        const parentId = this.parent.original[this.relationship.column];
+        if (parentId && !this.instance) {
+            this.setById(parentId);
+        }
+    }
+    static relationship(metadata, entityClass, property, type, inverseBy, options) {
+        metadata.relationships[property] = new BelongsToField(entityClass, property, type, inverseBy, options?.column);
+        return metadata;
+    }
+    get() {
+        return this.instance;
+    }
+    set(instance) {
+        if (instance instanceof Entity_1.Entity) {
+            this.instance = instance;
+        }
+        else {
+            this.setById(instance);
+        }
+    }
+    setById(id) {
+        this.set(this.relationship.related.new({ [this.relationship.related.getPrimaryKey()]: id }));
+    }
+    async save(data = {}) {
+        if (!this.instance) {
+            return;
+        }
+        this.instance.fill({
+            ...data,
+        });
+        await this.instance.save();
+        return this.instance;
+    }
+    toJSON() {
+        return this.instance?.toJSON();
+    }
+}
+exports.BelongsTo = BelongsTo;
+class HasOne extends BaseRelationship_1.BaseRelationship {
+    static relationship(metadata, entityClass, property, type, inverseBy, options) {
+        metadata.inverseRelationships[property] = new HasOneField(entityClass, property, type, inverseBy);
+        return metadata;
+    }
+    get() {
+        return this.instance;
+    }
+    set(instance) {
+        if (!instance) {
+            return;
+        }
+        if (instance instanceof Entity_1.Entity) {
+            this.instance = instance;
+        }
+        else {
+            this.setById(instance);
+        }
+    }
+    setById(id) {
+        this.set(this.relationship.related.new({ [this.relationship.related.getPrimaryKey()]: id }));
+    }
+    async save(instance = this.instance) {
+        this.set(instance);
+        if (instance) {
+            instance[this.relationship.inverseBy].set(this.parent);
+            await instance.save();
+        }
+        return this.instance;
+    }
+    toJSON() {
+        return this.instance?.toJSON();
+    }
+}
+exports.HasOne = HasOne;
+class HasMany extends List_1.List {
+    constructor(relationship, parent) {
+        super(relationship, parent);
+        this.relationship = relationship;
+    }
+    static relationship(metadata, entityClass, property, type, inverseBy, options) {
+        metadata.inverseRelationships[property] = new HasManyField(entityClass, property, type, inverseBy);
+        return metadata;
+    }
+    async save(item) {
+        const instances = await this.saveMany(item);
+        return instances.first();
+    }
+    async saveMany(...items) {
+        if (!this.parent.exists) {
+            await this.parent.save();
+        }
+        const instances = await this.relationship.save(items, this.parent);
+        this.items.push(...instances);
+        return instances;
+    }
+    async clear() {
+    }
+}
+exports.HasMany = HasMany;
+class BelongsToMany extends List_1.List {
+    constructor(relationship, parent) {
+        super(relationship, parent);
+        this.relationship = relationship;
+    }
+    static relationship(metadata, entityClass, property, type, inverseBy, options) {
+        // options.column = options.column || (property as string) + (entityClass.getPrimaryKey() as string).capitalize();
+        const inverseField = metadata.inverseRelationships[inverseBy];
+        metadata.inverseRelationships[property] = new BelongsToManyField(entityClass, property, type, inverseBy, options?.table || inverseField?.table, options?.foreignColumn || inverseField?.parentColumn, options?.column || inverseField?.relatedColumn);
+        return metadata;
+    }
+    async has(item) {
+        if (item instanceof Entity_1.Entity) {
+            item = item.getPrimaryKeyValue();
+        }
+        const relatedForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getRelatedForeignKey()}`;
+        const parentForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getParentForeignKey()}`;
+        return Boolean(await index_1.Query.table(this.relationship.getPivotTable())
+            .where(parentForeignKey, this.parent[this.parent.getPrimaryKey()])
+            .andWhere(relatedForeignKey, item)
+            .first());
+    }
+    async add(...items) {
+        const ids = items.map(item => item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item);
+        if (!this.parent.exists) {
+            await this.parent.save();
+        }
+        for await (const id of ids) {
+            if (!(await this.has(id))) {
+                this.items = this.items.concat(await this.relationship.add(items, this.parent));
+            }
+        }
+        return this.items;
+    }
+    async remove(...items) {
+        const ids = items.map(item => item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item);
+        const relatedForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getRelatedForeignKey()}`;
+        const parentForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getParentForeignKey()}`;
+        await index_1.Query.table(this.relationship.getPivotTable())
+            .where(parentForeignKey, this.parent[this.parent.getPrimaryKey()])
+            .whereIn(relatedForeignKey, ids)
+            .delete();
+        this.items = this.items.filter(item => !ids.includes(item.getPrimaryKeyValue()));
+    }
+    async toggle(...items) {
+        const ids = items.map(item => item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item);
+        const attachedEntities = await this.relationship.getQuery(this.parent).get();
+        const entitiesToDetach = ids.filter(item => attachedEntities.some(entity => entity.getPrimaryKeyValue() === item));
+        const entitiesToAttach = ids.filter(item => attachedEntities.some(entity => entity.getPrimaryKeyValue() !== item));
+        await this.add(...entitiesToAttach);
+        await this.remove(...entitiesToDetach);
+    }
+    async clear() {
+        const relatedForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getRelatedForeignKey()}`;
+        const parentForeignKey = `${this.relationship.getPivotTable()}.${this.relationship.getParentForeignKey()}`;
+        await index_1.Query.table(this.relationship.getPivotTable())
+            .where(parentForeignKey, this.parent[this.parent.getPrimaryKey()])
+            .whereIn(relatedForeignKey, this.items.pluck(this.relationship.related.getPrimaryKey()))
+            .delete();
+        this.items = [];
+    }
+    async sync(...items) {
+        const ids = items.map(item => item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item);
+        const existingItems = await this.get();
+        const primaryKey = this.relationship.type().getPrimaryKey();
+        const itemsToRemove = existingItems.filter(item => !ids.includes(item[primaryKey])).pluck(primaryKey);
+        const restOfItemsToAdd = ids.filter(item => !existingItems.findWhere(primaryKey, item));
+        await this.remove(...itemsToRemove);
+        await this.add(...restOfItemsToAdd);
+    }
+    async syncWithoutDetaching(...items) {
+        const ids = items.map(item => item instanceof Entity_1.Entity ? item.getPrimaryKeyValue() : item);
+        const existingItems = await this.get();
+        const primaryKey = this.relationship.type().getPrimaryKey();
+        const restOfItemsToAdd = ids.filter(item => !existingItems.findWhere(primaryKey, item));
+        await this.add(...restOfItemsToAdd);
+    }
+}
+exports.BelongsToMany = BelongsToMany;
 //# sourceMappingURL=Fields.js.map