@spinajs/orm-sql 2.0.28 → 2.0.39

package/lib/orm/src/relations.js

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