@spinajs/orm-sql 2.0.46 → 2.0.48

package/lib/orm/src/relations.js

@@ -1,681 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var OneToManyRelation_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OneToManyRelationList = exports.ManyToManyRelationList = exports.Relation = exports.SingleRelation = exports.ManyToManyRelation = exports.OneToManyRelation = exports.BelongsToRecursiveRelation = exports.BelongsToRelation = exports.DiscriminationMapMiddleware = exports.OrmRelation = void 0;
-/* eslint-disable prettier/prettier */
-const exceptions_1 = require("@spinajs/exceptions");
-const interfaces_1 = require("./interfaces");
-const di_1 = require("@spinajs/di");
-const builders_1 = require("./builders");
-const model_1 = require("./model");
-const orm_1 = require("./orm");
-const _ = __importStar(require("lodash"));
-class OrmRelation {
-    constructor(_orm, _query, _description, parentRelation) {
-        var _a;
-        this._orm = _orm;
-        this._query = _query;
-        this._description = _description;
-        this.parentRelation = parentRelation;
-        if (this._description) {
-            this._targetModel = (_a = this._description.TargetModel) !== null && _a !== void 0 ? _a : undefined;
-        }
-        this._targetModelDescriptor = (0, model_1.extractModelDescriptor)(this._targetModel);
-        const driver = this._orm.Connections.get(this._targetModelDescriptor.Connection);
-        const cnt = driver.Container;
-        this._relationQuery = cnt.resolve(builders_1.SelectQueryBuilder, [driver, this._targetModel, this]);
-        this._separator = driver.Options.AliasSeparator;
-        if (driver.Options.Database) {
-            this._relationQuery.database(driver.Options.Database);
-        }
-    }
-    get Alias() {
-        return this.parentRelation ? `${this.parentRelation.Alias}.${this._separator}${this._description.Name}${this._separator}` : `${this._separator}${this._description.Name}${this._separator}`;
-    }
-    executeOnQuery(callback) {
-        callback.call(this._relationQuery, [this]);
-    }
-}
-exports.OrmRelation = OrmRelation;
-class HasManyRelationMiddleware {
-    constructor(_relationQuery, _description, _path) {
-        this._relationQuery = _relationQuery;
-        this._description = _description;
-        this._path = _path;
-    }
-    afterQuery(data) {
-        return data;
-    }
-    modelCreation(_) {
-        return null;
-    }
-    async afterHydration(data) {
-        const self = this;
-        const pks = data.map((d) => {
-            if (this._path) {
-                return _.get(d, this._path)[this._description.PrimaryKey];
-            }
-            else {
-                return d[this._description.PrimaryKey];
-            }
-        });
-        const hydrateMiddleware = {
-            afterQuery(data) {
-                return data;
-            },
-            modelCreation() {
-                return null;
-            },
-            async afterHydration(relationData) {
-                relationData.forEach((d) => (d.__relationKey__ = self._description.Name));
-                data.forEach((d) => {
-                    const relData = relationData.filter((rd) => {
-                        if (self._path) {
-                            return _.get(d, self._path)[self._description.PrimaryKey] === rd[self._description.ForeignKey];
-                        }
-                        else {
-                            return rd[self._description.ForeignKey] === d[self._description.PrimaryKey];
-                        }
-                    });
-                    if (self._path) {
-                        _.get(d, self._path)[self._description.Name] = new OneToManyRelationList(d, self._description.TargetModel, self._description, relData);
-                    }
-                    else {
-                        d[self._description.Name] = new OneToManyRelationList(d, self._description.TargetModel, self._description, relData);
-                    }
-                });
-            },
-        };
-        if (pks.length !== 0) {
-            this._relationQuery.whereIn(this._description.ForeignKey, pks);
-            this._relationQuery.middleware(hydrateMiddleware);
-            return await this._relationQuery;
-        }
-        return [];
-    }
-}
-class BelongsToRelationRecursiveMiddleware {
-    constructor(_relationQuery, _description, _targetModelDescriptor) {
-        this._relationQuery = _relationQuery;
-        this._description = _description;
-        this._targetModelDescriptor = _targetModelDescriptor;
-    }
-    afterQuery(data) {
-        return data;
-    }
-    modelCreation(_) {
-        return null;
-    }
-    async afterHydration(data) {
-        const self = this;
-        const pks = data.map((d) => d[this._description.PrimaryKey]);
-        const hydrateMiddleware = {
-            afterQuery(data) {
-                return data;
-            },
-            modelCreation(_) {
-                return null;
-            },
-            async afterHydration(relationData) {
-                relationData.forEach((d) => (d.__relationKey__ = self._description.Name));
-                const roots = relationData.filter((rd) => rd[self._description.ForeignKey] === 0 || rd[self._description.ForeignKey] === null);
-                const leafs = roots.map((r) => {
-                    return fillRecursive(r);
-                    function fillRecursive(parent) {
-                        const child = relationData.find((rd) => rd[self._description.ForeignKey] === parent[self._description.PrimaryKey]);
-                        if (!child) {
-                            return parent;
-                        }
-                        child[self._description.Name] = new SingleRelation(child, self._description.TargetModel, self._description, parent);
-                        return fillRecursive(child);
-                    }
-                });
-                data.forEach((d) => {
-                    const val = leafs.find((l) => l[self._description.PrimaryKey] === d[self._description.PrimaryKey])[self._description.Name];
-                    const rel = val;
-                    d[self._description.Name] = rel;
-                });
-            },
-        };
-        this._relationQuery.whereIn(this._description.PrimaryKey, pks);
-        this._relationQuery.middleware(new DiscriminationMapMiddleware(this._targetModelDescriptor));
-        this._relationQuery.middleware(hydrateMiddleware);
-        return await this._relationQuery;
-    }
-}
-class HasManyToManyRelationMiddleware {
-    constructor(_relationQuery, _description, _targetModelDescriptor) {
-        this._relationQuery = _relationQuery;
-        this._description = _description;
-        this._targetModelDescriptor = _targetModelDescriptor;
-    }
-    afterQuery(data) {
-        return data;
-    }
-    modelCreation(_) {
-        return null;
-    }
-    async afterHydration(data) {
-        const self = this;
-        const pks = data.map((d) => d[this._description.PrimaryKey]);
-        const hydrateMiddleware = {
-            afterQuery(data) {
-                return data.map((d) => Object.assign({}, d[self._description.Name], { JunctionModel: self.pickProps(d, [self._description.Name]) }));
-            },
-            modelCreation(_) {
-                return null;
-            },
-            async afterHydration(relationData) {
-                relationData.forEach((d) => (d.__relationKey__ = self._description.Name));
-                data.forEach((d) => {
-                    const relData = relationData.filter((rd) => rd.JunctionModel[self._description.ForeignKey] === d[self._description.PrimaryKey]);
-                    d[self._description.Name] = new ManyToManyRelationList(d, self._description.TargetModel, self._description, relData);
-                });
-                relationData.forEach((d) => delete d.JunctionModel);
-            },
-        };
-        if (pks.length !== 0) {
-            this._relationQuery.whereIn(this._description.ForeignKey, pks);
-            this._relationQuery.middleware(new BelongsToRelationResultTransformMiddleware(this._description));
-            this._relationQuery.middleware(new DiscriminationMapMiddleware(this._targetModelDescriptor));
-            this._relationQuery.middleware(hydrateMiddleware);
-            return await this._relationQuery;
-        }
-        return [];
-    }
-    pickProps(source, except) {
-        const obj = {};
-        for (const p in source) {
-            if (except.indexOf(p) === -1) {
-                obj[p] = source[p];
-            }
-        }
-        return obj;
-    }
-}
-class BelongsToRelationResultTransformMiddleware {
-    constructor(_description) {
-        this._description = _description;
-    }
-    afterQuery(data) {
-        return data.map((d) => {
-            const transformedData = Object.assign(d);
-            for (const key in transformedData) {
-                if (key.startsWith('$')) {
-                    this.setDeep(transformedData, this.keyTransform(key), d[key]);
-                    delete transformedData[key];
-                }
-            }
-            return transformedData;
-        });
-    }
-    modelCreation(_) {
-        return null;
-    }
-    // tslint:disable-next-line: no-empty
-    async afterHydration(_data) { }
-    /**
-     * Dynamically sets a deeply nested value in an object.
-     * Optionally "bores" a path to it if its undefined.
-     *
-     * @param obj  - The object which contains the value you want to change/set.
-     * @param path  - The array representation of path to the value you want to change/set.
-     * @param value - The value you want to set it to.
-     * @param setrecursively - If true, will set value of non-existing path as well.
-     */
-    setDeep(obj, path, value, setrecursively = true) {
-        path.reduce((a, b, level) => {
-            if (setrecursively && typeof a[b] === 'undefined' && level !== path.length - 1) {
-                a[b] = {};
-                return a[b];
-            }
-            if (level === path.length - 1) {
-                a[b] = value;
-                return value;
-            }
-            return a[b];
-        }, obj);
-    }
-    keyTransform(key) {
-        return key.replace(/\$+/g, '').split('.');
-    }
-}
-class BelongsToRelationResultTransformOneToManyMiddleware extends BelongsToRelationResultTransformMiddleware {
-    keyTransform(key) {
-        return key.replace(/\$+/g, '').split('.');
-    }
-}
-class DiscriminationMapMiddleware {
-    constructor(_description) {
-        this._description = _description;
-    }
-    afterQuery(data) {
-        return data;
-    }
-    modelCreation(data) {
-        if (this._description.DiscriminationMap && this._description.DiscriminationMap.Field) {
-            const distValue = data[this._description.DiscriminationMap.Field];
-            if (distValue && this._description.DiscriminationMap.Models.has(distValue)) {
-                const result = new (this._description.DiscriminationMap.Models.get(distValue))();
-                result.hydrate(data);
-                return result;
-            }
-        }
-        return null;
-    }
-    // tslint:disable-next-line: no-empty
-    async afterHydration(_data) { }
-}
-exports.DiscriminationMapMiddleware = DiscriminationMapMiddleware;
-let BelongsToRelation = class BelongsToRelation extends OrmRelation {
-    constructor(_orm, _query, _description, _parentRelation) {
-        super(_orm, _query, _description, _parentRelation);
-        this._relationQuery.from(this._targetModelDescriptor.TableName, this.Alias);
-        this._targetModelDescriptor.Columns.forEach((c) => {
-            this._relationQuery.select(c.Name, `${this.Alias}.${c.Name}`);
-        });
-    }
-    execute(callback) {
-        if (!this.parentRelation && !this._query.TableAlias) {
-            this._query.setAlias(`${this._separator}${this._description.SourceModel.name}${this._separator}`);
-        }
-        this._query.leftJoin(this._targetModelDescriptor.TableName, this.Alias, this._description.ForeignKey, `${this._description.PrimaryKey}`);
-        if (callback) {
-            callback.call(this._relationQuery, [this]);
-        }
-        this._query.mergeStatements(this._relationQuery);
-        if (!this.parentRelation) {
-            // if we are on top of the belongsTo relation stack
-            // add transform middleware
-            // we do this becouse belongsTo modifies query (not creating new like oneToMany and manyToMany)
-            // and we only need to run transform once
-            this._query.middleware(new BelongsToRelationResultTransformMiddleware(this._description));
-        }
-        else if (!this.parentRelation.parentRelation && this.parentRelation instanceof OneToManyRelation) {
-            // if we called populate from OneToMany relation
-            // we must use different path transform ( couse onetomany is separate query)
-            // otherwise we would fill invalid property on entity
-            this._query.middleware(new BelongsToRelationResultTransformOneToManyMiddleware(this._description));
-        }
-    }
-};
-BelongsToRelation = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.Orm, builders_1.SelectQueryBuilder, Object, OrmRelation])
-], BelongsToRelation);
-exports.BelongsToRelation = BelongsToRelation;
-let BelongsToRecursiveRelation = class BelongsToRecursiveRelation extends OrmRelation {
-    constructor(_orm, _query, _description, _parentRelation) {
-        super(_orm, _query, _description, _parentRelation);
-        this._relationQuery.withRecursive(this._description.ForeignKey, this._description.PrimaryKey).from(this._targetModelDescriptor.TableName, this.Alias);
-        this._targetModelDescriptor.Columns.forEach((c) => {
-            this._relationQuery.select(c.Name, `${this.Alias}.${c.Name}`);
-        });
-    }
-    execute(callback) {
-        if (callback) {
-            callback.call(this._relationQuery, [this]);
-        }
-        this._query.middleware(new BelongsToRelationRecursiveMiddleware(this._relationQuery, this._description, this._targetModelDescriptor));
-    }
-};
-BelongsToRecursiveRelation = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.Orm, builders_1.SelectQueryBuilder, Object, OrmRelation])
-], BelongsToRecursiveRelation);
-exports.BelongsToRecursiveRelation = BelongsToRecursiveRelation;
-let OneToManyRelation = OneToManyRelation_1 = class OneToManyRelation extends OrmRelation {
-    constructor(_orm, _query, _description, _parentRelation) {
-        super(_orm, _query, _description, _parentRelation);
-        this._relationQuery.from(this._targetModelDescriptor.TableName, this.Alias);
-        this._relationQuery.columns(this._targetModelDescriptor.Columns.map((c) => {
-            return c.Name;
-        }));
-    }
-    execute(callback) {
-        if (!this.parentRelation && !this._query.TableAlias) {
-            this._query.setAlias(`${this._separator}${this._description.SourceModel.name}${this._separator}`);
-        }
-        const path = [];
-        let cur = this.parentRelation;
-        while (cur && !(cur instanceof OneToManyRelation_1)) {
-            path.push(cur._description.Name);
-            cur = cur.parentRelation;
-        }
-        if (callback) {
-            callback.call(this._relationQuery, [this]);
-        }
-        this._query.middleware(new DiscriminationMapMiddleware(this._targetModelDescriptor));
-        this._query.middleware(new HasManyRelationMiddleware(this._relationQuery, this._description, path.join('.')));
-    }
-};
-OneToManyRelation = OneToManyRelation_1 = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.Orm, builders_1.SelectQueryBuilder, Object, OrmRelation])
-], OneToManyRelation);
-exports.OneToManyRelation = OneToManyRelation;
-let ManyToManyRelation = class ManyToManyRelation extends OrmRelation {
-    constructor(_orm, _query, _description, _parentRelation) {
-        var _a, _b;
-        super(_orm, _query, _description, _parentRelation);
-        this._joinModel = (_b = (_a = this._orm.Models.find((m) => { var _a; return m.name === ((_a = this._description.JunctionModel) === null || _a === void 0 ? void 0 : _a.name); })) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : undefined;
-        if (this._joinModel === undefined) {
-            throw new exceptions_1.InvalidOperation(`model ${this._description.JunctionModel} not exists in orm module`);
-        }
-        this._joinModelDescriptor = (0, model_1.extractModelDescriptor)(this._joinModel);
-        const orm = di_1.DI.get(orm_1.Orm);
-        const driver = orm.Connections.get(this._targetModelDescriptor.Connection);
-        const cnt = driver.Container;
-        this._joinQuery = cnt.resolve(builders_1.SelectQueryBuilder, [driver, this._targetModel, this]);
-        if (driver.Options.Database) {
-            this._joinQuery.database(driver.Options.Database);
-        }
-        this._joinQuery.from(this._joinModelDescriptor.TableName, `${this._separator}${this._joinModelDescriptor.TableName}${this._separator}`);
-        this._joinQuery.columns(this._joinModelDescriptor.Columns.map((c) => {
-            return c.Name;
-        }));
-        this._relationQuery.from(this._targetModelDescriptor.TableName, this.Alias);
-        this._targetModelDescriptor.Columns.forEach((c) => {
-            this._relationQuery.select(c.Name, `${this.Alias}.${c.Name}`);
-        });
-    }
-    get TableJoinQuery() {
-        return this._joinQuery;
-    }
-    get RelationQuery() {
-        return this._relationQuery;
-    }
-    execute(callback) {
-        this._joinQuery.leftJoin(this._targetModelDescriptor.TableName, this.Alias, this._description.JunctionModelTargetModelFKey_Name, this._description.ForeignKey);
-        if (callback) {
-            callback.call(this._relationQuery, [this]);
-        }
-        const joinRelationDescriptor = {
-            Name: this._description.Name,
-            Type: interfaces_1.RelationType.Many,
-            TargetModelType: this._description.JunctionModel,
-            TargetModel: this._description.JunctionModel,
-            SourceModel: this._description.SourceModel,
-            ForeignKey: this._description.JunctionModelSourceModelFKey_Name,
-            PrimaryKey: this._description.PrimaryKey,
-            Recursive: false,
-        };
-        this._joinQuery.mergeStatements(this._relationQuery);
-        this._query.middleware(new HasManyToManyRelationMiddleware(this._joinQuery, joinRelationDescriptor, this._targetModelDescriptor));
-    }
-};
-ManyToManyRelation = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.Orm, builders_1.SelectQueryBuilder, Object, OrmRelation])
-], ManyToManyRelation);
-exports.ManyToManyRelation = ManyToManyRelation;
-class SingleRelation {
-    constructor(_owner, model, Relation, object) {
-        this._owner = _owner;
-        this.model = model;
-        this.Relation = Relation;
-        this.Populated = false;
-        this.TargetModelDescriptor = (0, model_1.extractModelDescriptor)(model);
-        this.Orm = di_1.DI.get(orm_1.Orm);
-        this.Value = object;
-    }
-    async set(obj) {
-        this.Value = obj;
-        await this._owner.update();
-    }
-    attach(obj) {
-        this.Value = obj;
-    }
-    detach() {
-        this.Value = null;
-    }
-    async remove() {
-        this.Value = null;
-        await this.Value.destroy();
-        await this._owner.update();
-    }
-    async populate(callback) {
-        /**
-         * Do little cheat - we construct query that loads initial model with given relation.
-         * Then we only assign relation property.
-         *
-         * TODO: create only relation query without loading its owner.
-         */
-        const query = (0, model_1.createQuery)(this.Relation.TargetModel, (builders_1.SelectQueryBuilder)).query;
-        const desc = (0, model_1.extractModelDescriptor)(this.Relation.TargetModel);
-        query.where({ [desc.PrimaryKey]: this._owner[this.Relation.ForeignKey] });
-        if (callback) {
-            callback.apply(query);
-        }
-        const result = await query.firstOrFail();
-        if (result) {
-            this.Value = result;
-        }
-        this.Populated = true;
-    }
-}
-exports.SingleRelation = SingleRelation;
-/**
- * Iterable list of populated relation entities
- *
- * It allows to add / remove objects to relation
- */
-class Relation extends Array {
-    constructor(owner, model, Relation, objects) {
-        super();
-        this.owner = owner;
-        this.model = model;
-        this.Relation = Relation;
-        this.Populated = false;
-        if (objects) {
-            this.push(...objects);
-        }
-        this.TargetModelDescriptor = (0, model_1.extractModelDescriptor)(model);
-        this.Orm = di_1.DI.get(orm_1.Orm);
-    }
-    /**
-     * Delete all objects from relation
-     */
-    async clear() {
-        await this.remove(this);
-    }
-    empty() {
-        this.length = 0;
-    }
-    /**
-     * Populates this relation
-     */
-    async populate(callback) {
-        const query = this.Relation.TargetModel.where(this.Relation.ForeignKey, this.owner.PrimaryKeyValue);
-        if (callback) {
-            callback.apply(query);
-        }
-        const result = await query;
-        if (result) {
-            this.length = 0;
-            this.push(...result);
-        }
-        this.Populated = true;
-    }
-}
-exports.Relation = Relation;
-class ManyToManyRelationList extends Relation {
-    intersection(_obj, _callback) {
-        throw new Error('Method not implemented.');
-    }
-    union(_obj, _mode) {
-        throw new Error('Method not implemented.');
-    }
-    diff(_obj, _callback) {
-        throw new Error('Method not implemented.');
-    }
-    set(_obj, _callback) {
-        throw new Error('Method not implemented.');
-    }
-    async remove(obj) {
-        const self = this;
-        const data = (Array.isArray(obj) ? obj : [obj]).map((d) => d.PrimaryKeyValue);
-        const driver = this.Orm.Connections.get(this.TargetModelDescriptor.Connection);
-        const jmodelDescriptor = (0, model_1.extractModelDescriptor)(this.Relation.JunctionModel);
-        if (!driver) {
-            throw new exceptions_1.InvalidArgument(`connection ${this.TargetModelDescriptor.Connection} not exists`);
-        }
-        const query = driver.Container.resolve(builders_1.DeleteQueryBuilder, [driver, this.Relation.JunctionModel])
-            .from(jmodelDescriptor.TableName)
-            .where(function () {
-            this.whereIn(self.Relation.JunctionModelTargetModelFKey_Name, data);
-            this.andWhere(self.Relation.JunctionModelSourceModelFKey_Name, self.owner.PrimaryKeyValue);
-        });
-        await query;
-        _.remove(this, (o) => data.indexOf(o.PrimaryKeyValue) !== -1);
-    }
-    async add(obj, mode) {
-        const data = Array.isArray(obj) ? obj : [obj];
-        const relEntities = data.map((d) => {
-            const relEntity = new this.Relation.JunctionModel();
-            relEntity[this.Relation.JunctionModelSourceModelFKey_Name] = this.owner.PrimaryKeyValue;
-            relEntity[this.Relation.JunctionModelTargetModelFKey_Name] = d.PrimaryKeyValue;
-            return relEntity;
-        });
-        for (const m of relEntities) {
-            await m.insert(mode);
-        }
-        this.push(...data);
-    }
-}
-exports.ManyToManyRelationList = ManyToManyRelationList;
-class OneToManyRelationList extends Relation {
-    async diff(obj, callback) {
-        const result = callback ? _.differenceWith(obj, [...this], callback) : _.differenceBy(obj, [...this], this.TargetModelDescriptor.PrimaryKey);
-        const result2 = callback ? _.differenceWith([...this], obj, callback) : _.differenceBy([...this], obj, this.TargetModelDescriptor.PrimaryKey);
-        const finalDiff = [...result, ...result2];
-        const self = this;
-        const driver = this.Orm.Connections.get(this.TargetModelDescriptor.Connection);
-        const relData = finalDiff.filter((x) => x.PrimaryKeyValue).map((x) => x.PrimaryKeyValue);
-        const query = driver.Container.resolve(builders_1.DeleteQueryBuilder, [driver, this.Relation.TargetModel]).andWhere(function () {
-            if (relData.length !== 0) {
-                this.whereNotIn(self.Relation.PrimaryKey, relData);
-            }
-            this.where(self.Relation.ForeignKey, self.owner.PrimaryKeyValue);
-        });
-        query.setTable(this.TargetModelDescriptor.TableName);
-        if (driver.Options.Database) {
-            query.database(driver.Options.Database);
-        }
-        await query;
-        this.empty();
-        await this.add(finalDiff), interfaces_1.InsertBehaviour.InsertOrUpdate;
-    }
-    async set(obj) {
-        const self = this;
-        const driver = this.Orm.Connections.get(this.TargetModelDescriptor.Connection);
-        const query = driver.Container.resolve(builders_1.DeleteQueryBuilder, [driver, this.Relation.TargetModel]).andWhere(function () {
-            const relData = obj.filter((x) => x.PrimaryKeyValue).map((x) => x.PrimaryKeyValue);
-            if (relData.length !== 0) {
-                this.whereNotIn(self.Relation.PrimaryKey, relData);
-            }
-            this.where(self.Relation.ForeignKey, self.owner.PrimaryKeyValue);
-        });
-        query.setTable(this.TargetModelDescriptor.TableName);
-        if (driver.Options.Database) {
-            query.database(driver.Options.Database);
-        }
-        await query;
-        this.empty();
-        await this.add(obj, interfaces_1.InsertBehaviour.InsertOrUpdate);
-    }
-    async intersection(obj, callback) {
-        const self = this;
-        const result = callback ? _.intersectionWith(obj, [...this], callback) : _.intersectionBy(obj, [...this], this.TargetModelDescriptor.PrimaryKey);
-        const driver = this.Orm.Connections.get(this.TargetModelDescriptor.Connection);
-        const query = driver.Container.resolve(builders_1.DeleteQueryBuilder, [driver, this.Relation.TargetModel]).andWhere(function () {
-            const relData = result.filter((x) => x.PrimaryKeyValue).map((x) => x.PrimaryKeyValue);
-            if (relData.length !== 0) {
-                this.whereNotIn(self.Relation.PrimaryKey, relData);
-            }
-            this.where(self.Relation.ForeignKey, self.owner.PrimaryKeyValue);
-        });
-        query.setTable(this.TargetModelDescriptor.TableName);
-        if (driver.Options.Database) {
-            query.database(driver.Options.Database);
-        }
-        await query;
-        this.empty();
-        await this.add(result, interfaces_1.InsertBehaviour.InsertOrUpdate);
-    }
-    async union(obj, mode) {
-        await this.add(obj, mode);
-    }
-    async remove(obj) {
-        const data = (Array.isArray(obj) ? obj : [obj]).map((d) => d.PrimaryKeyValue);
-        const driver = this.Orm.Connections.get(this.TargetModelDescriptor.Connection);
-        if (!driver) {
-            throw new exceptions_1.InvalidArgument(`connection ${this.TargetModelDescriptor.Connection} not exists`);
-        }
-        const query = driver.Container.resolve(builders_1.DeleteQueryBuilder, [driver, this.Relation.TargetModel]).whereIn(this.Relation.ForeignKey, data);
-        query.setTable(this.TargetModelDescriptor.TableName);
-        if (driver.Options.Database) {
-            query.database(driver.Options.Database);
-        }
-        await query;
-        _.remove(this, (o) => data.indexOf(o.PrimaryKeyValue) !== -1);
-    }
-    async add(obj, mode) {
-        const data = Array.isArray(obj) ? obj : [obj];
-        const tInsert = data.map((x) => {
-            if (x instanceof model_1.ModelBase) {
-                return x;
-            }
-            if (_.isFunction(this.model)) {
-                return new (this.model())(x);
-            }
-            return new this.model(x);
-        });
-        data.forEach((d) => {
-            d[this.Relation.ForeignKey] = this.owner.PrimaryKeyValue;
-        });
-        for (const m of data) {
-            if (m.PrimaryKeyValue) {
-                await m.update();
-            }
-            else {
-                await m.insert(mode);
-            }
-        }
-        this.push(...tInsert);
-    }
-}
-exports.OneToManyRelationList = OneToManyRelationList;
-//# sourceMappingURL=relations.js.map