@spinajs/orm 2.0.175 → 2.0.176

package/lib/mjs/relations.js

@@ -10,290 +10,48 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var BelongsToRelation_1;
 /* eslint-disable prettier/prettier */
 import { InvalidOperation } from '@spinajs/exceptions';
-import { RelationType, InsertBehaviour } from './interfaces.js';
-import { NewInstance, DI, isConstructor } from '@spinajs/di';
-import { SelectQueryBuilder } from './builders.js';
-import { createQuery, extractModelDescriptor, ModelBase } from './model.js';
+import { RelationType } from './interfaces.js';
+import { NewInstance, DI, Inject, Container } from '@spinajs/di';
+import { BelongsToPopulateDataMiddleware, BelongsToRelationRecursiveMiddleware, BelongsToRelationResultTransformMiddleware, DiscriminationMapMiddleware, HasManyRelationMiddleware, HasManyToManyRelationMiddleware } from './middlewares.js';
+import { extractModelDescriptor } from './model.js';
 import { Orm } from './orm.js';
-import _ from 'lodash';
-export class OrmRelation {
+function _paramCheck(callback, err) {
+    const val = callback();
+    if (!callback()) {
+        throw new Error(err);
+    }
+    return val;
+}
+let OrmRelation = class OrmRelation {
     get Alias() {
         return this.parentRelation ? `${this.parentRelation.Alias}.${this._separator}${this._description.Name}${this._separator}` : `${this._separator}${this._description.Name}${this._separator}`;
     }
-    constructor(_orm, _query, _description, parentRelation) {
-        this._orm = _orm;
+    constructor(_container, _query, _description, parentRelation) {
+        this._container = _container;
         this._query = _query;
         this._description = _description;
         this.parentRelation = parentRelation;
-        if (this._description) {
-            this._targetModel = this._description.TargetModel ?? undefined;
-        }
-        this._targetModelDescriptor = extractModelDescriptor(this._targetModel);
-        const driver = this._orm.Connections.get(this._targetModelDescriptor.Connection);
-        const cnt = driver.Container;
-        this._relationQuery = cnt.resolve(SelectQueryBuilder, [driver, this._targetModel, this]);
-        this._separator = driver.Options.AliasSeparator;
-        if (driver.Options.Database) {
-            this._relationQuery.database(driver.Options.Database);
+        this._targetModel = this._description.TargetModel;
+        this._targetModelDescriptor = _paramCheck(() => extractModelDescriptor(this._targetModel), `Model ${this._targetModel?.name} does not have model descriptor set`);
+        this._driver = _paramCheck(() => DI.resolve("OrmConnection", [this._targetModelDescriptor.Connection]), `Connection ${this._targetModelDescriptor.Connection} is not set in configuration file`);
+        this._relationQuery = this._container.resolve("SelectQueryBuilder", [this._driver, this._targetModel, this]);
+        this._separator = this._driver.Options.AliasSeparator;
+        if (this._driver.Options.Database) {
+            this._relationQuery.database(this._driver.Options.Database);
         }
     }
     executeOnQuery(callback) {
         callback.call(this._relationQuery, [this]);
     }
-}
-export 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) => {
-            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) => {
-                        return d[self._description.PrimaryKey] === rd[self._description.ForeignKey];
-                    });
-                    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 fKey = this._description.ForeignKey;
-        const key = this._description.PrimaryKey;
-        const name = this._description.Name;
-        const hydrateMiddleware = {
-            afterQuery(data) {
-                return data;
-            },
-            modelCreation(_) {
-                return null;
-            },
-            async afterHydration(relationData) {
-                relationData.forEach((d) => (d.__relationKey__ = self._description.Name));
-                function buildRelationTree(_d, parent) {
-                    const branch = [];
-                    _d.forEach((d) => {
-                        if (d[fKey] === parent) {
-                            const children = buildRelationTree(_d, d[key]);
-                            if (children) {
-                                // TODO:
-                                // implement RecursiveRelation list to allow for
-                                // manipulation of the recursive data
-                                d[name] = new OneToManyRelationList(d, d.Model, {
-                                    Name: name,
-                                    Type: RelationType.Many,
-                                    TargetModelType: d.Model,
-                                    TargetModel: d.Model,
-                                    SourceModel: d.Model,
-                                    ForeignKey: fKey,
-                                    PrimaryKey: key,
-                                    Recursive: false,
-                                }, children);
-                            }
-                            branch.push(d);
-                        }
-                    });
-                    return branch;
-                }
-                const result = buildRelationTree(relationData, null);
-                data.forEach((d) => {
-                    d[name] = result.find((r) => r[key] === d[key])[name];
-                });
-            },
-        };
-        this._relationQuery.whereIn(this._description.PrimaryKey, pks);
-        this._relationQuery.middleware(new DiscriminationMapMiddleware(this._targetModelDescriptor));
-        this._relationQuery.middleware(hydrateMiddleware);
-        return await this._relationQuery;
-    }
-}
-export 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, null));
-            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 BelongsToPopulateDataMiddleware {
-    constructor(_description, relation) {
-        this._description = _description;
-        this.relation = relation;
-    }
-    afterQuery(data) {
-        return data;
-    }
-    modelCreation(_) {
-        return null;
-    }
-    afterHydration(data) {
-        const relData = data.map((d) => d[this._description.Name].Value).filter((x) => x !== null && x !== undefined);
-        const middlewares = this.relation._relationQuery.Relations
-            .map((x) => {
-            return x._query._middlewares;
-        })
-            .reduce((prev, current) => {
-            return prev.concat(current);
-        }, []);
-        return Promise.all(middlewares.map((x) => {
-            return x.afterHydration(relData);
-        }));
-    }
-}
-class BelongsToRelationResultTransformMiddleware {
-    constructor(_description, relation) {
-        this._description = _description;
-        this.relation = relation;
-    }
-    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('.');
-    }
-}
-export 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) { }
-}
+};
+OrmRelation = __decorate([
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, Object, Object, OrmRelation])
+], OrmRelation);
+export { OrmRelation };
 let BelongsToRelation = BelongsToRelation_1 = class BelongsToRelation extends OrmRelation {
-    constructor(_orm, _query, _description, _parentRelation) {
-        super(_orm, _query, _description, _parentRelation);
+    constructor(_container, _query, _description, _parentRelation) {
+        super(_container, _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}`);
@@ -307,6 +65,7 @@ let BelongsToRelation = BelongsToRelation_1 = class BelongsToRelation extends Or
         if (callback) {
             callback.call(this._relationQuery, [this]);
         }
+        // todo: fix this cast
         this._query.mergeBuilder(this._relationQuery);
         this._query.middleware(new BelongsToPopulateDataMiddleware(this._description, this));
         if (!this.parentRelation || !(this.parentRelation instanceof BelongsToRelation_1)) {
@@ -314,18 +73,19 @@ let BelongsToRelation = BelongsToRelation_1 = class BelongsToRelation extends Or
             // 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, this));
+            this._query.middleware(new BelongsToRelationResultTransformMiddleware());
         }
     }
 };
 BelongsToRelation = BelongsToRelation_1 = __decorate([
     NewInstance(),
-    __metadata("design:paramtypes", [Orm, SelectQueryBuilder, Object, OrmRelation])
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, Object, Object, OrmRelation])
 ], BelongsToRelation);
 export { BelongsToRelation };
 let BelongsToRecursiveRelation = class BelongsToRecursiveRelation extends OrmRelation {
-    constructor(_orm, _query, _description, _parentRelation) {
-        super(_orm, _query, _description, _parentRelation);
+    constructor(_container, _query, _description, _parentRelation) {
+        super(_container, _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}`);
@@ -340,12 +100,13 @@ let BelongsToRecursiveRelation = class BelongsToRecursiveRelation extends OrmRel
 };
 BelongsToRecursiveRelation = __decorate([
     NewInstance(),
-    __metadata("design:paramtypes", [Orm, SelectQueryBuilder, Object, OrmRelation])
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, Object, Object, OrmRelation])
 ], BelongsToRecursiveRelation);
 export { BelongsToRecursiveRelation };
 let OneToManyRelation = class OneToManyRelation extends OrmRelation {
-    constructor(_orm, _query, _description, _parentRelation) {
-        super(_orm, _query, _description, _parentRelation);
+    constructor(_container, _query, _description, _parentRelation) {
+        super(_container, _query, _description, _parentRelation);
         this._relationQuery.from(this._targetModelDescriptor.TableName, this.Alias);
         this._relationQuery.columns(this._targetModelDescriptor.Columns.map((c) => {
             return c.Name;
@@ -364,7 +125,8 @@ let OneToManyRelation = class OneToManyRelation extends OrmRelation {
 };
 OneToManyRelation = __decorate([
     NewInstance(),
-    __metadata("design:paramtypes", [Orm, SelectQueryBuilder, Object, OrmRelation])
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, Object, Object, OrmRelation])
 ], OneToManyRelation);
 export { OneToManyRelation };
 let ManyToManyRelation = class ManyToManyRelation extends OrmRelation {
@@ -374,8 +136,9 @@ let ManyToManyRelation = class ManyToManyRelation extends OrmRelation {
     get RelationQuery() {
         return this._relationQuery;
     }
-    constructor(_orm, _query, _description, _parentRelation) {
-        super(_orm, _query, _description, _parentRelation);
+    constructor(_container, _orm, _query, _description, _parentRelation) {
+        super(_container, _query, _description, _parentRelation);
+        this._orm = _orm;
         this._joinModel = this._orm.Models.find((m) => m.name === this._description.JunctionModel?.name)?.type ?? undefined;
         if (this._joinModel === undefined) {
             throw new InvalidOperation(`model ${this._description.JunctionModel} not exists in orm module`);
@@ -384,7 +147,7 @@ let ManyToManyRelation = class ManyToManyRelation extends OrmRelation {
         const orm = DI.get(Orm);
         const driver = orm.Connections.get(this._joinModelDescriptor.Connection);
         const cnt = driver.Container;
-        this._joinQuery = cnt.resolve(SelectQueryBuilder, [driver, this._targetModel, this]);
+        this._joinQuery = cnt.resolve("SelectQueryBuilder", [driver, this._targetModel, this]);
         if (driver.Options.Database) {
             this._joinQuery.database(driver.Options.Database);
         }
@@ -414,6 +177,7 @@ let ManyToManyRelation = class ManyToManyRelation extends OrmRelation {
             PrimaryKey: this._description.PrimaryKey,
             Recursive: false,
         };
+        // todo fix this cast
         this._joinQuery.mergeBuilder(this._relationQuery);
         this._joinQuery.mergeRelations(this._relationQuery);
         this._query.middleware(new HasManyToManyRelationMiddleware(this._joinQuery, joinRelationDescriptor, this._targetModelDescriptor));
@@ -421,211 +185,8 @@ let ManyToManyRelation = class ManyToManyRelation extends OrmRelation {
 };
 ManyToManyRelation = __decorate([
     NewInstance(),
-    __metadata("design:paramtypes", [Orm, SelectQueryBuilder, Object, OrmRelation])
+    Inject(Container, Orm),
+    __metadata("design:paramtypes", [Container, Orm, Object, Object, OrmRelation])
 ], ManyToManyRelation);
 export { ManyToManyRelation };
-export class SingleRelation {
-    constructor(_owner, model, Relation, object) {
-        this._owner = _owner;
-        this.model = model;
-        this.Relation = Relation;
-        this.Populated = false;
-        this.TargetModelDescriptor = extractModelDescriptor(model);
-        this.Orm = DI.get(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 = createQuery(this.Relation.TargetModel, (SelectQueryBuilder)).query;
-        const desc = 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;
-    }
-}
-/**
- * Iterable list of populated relation entities
- *
- * It allows to add / remove objects to relation
- */
-export 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 = extractModelDescriptor(Model);
-        this.Orm = DI.get(Orm);
-        if (this.TargetModelDescriptor) {
-            this.Driver = this.Orm.Connections.get(this.TargetModelDescriptor.Connection);
-        }
-        this.IsModelAForwardRef = !isConstructor(this.Model);
-    }
-    /**
-     * Delete all objects from relation
-     */
-    async clear() {
-        await this.remove(this);
-    }
-    empty() {
-        this.length = 0;
-    }
-    /**
-     * Populates this relation ( loads all data related to owner of 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;
-    }
-}
-export 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 jmodelDescriptor = extractModelDescriptor(this.Relation.JunctionModel);
-        const query = this.Driver.del()
-            .from(jmodelDescriptor.TableName)
-            .where(function () {
-            this.whereIn(self.Relation.JunctionModelTargetModelFKey_Name, data);
-            this.andWhere(self.Relation.JunctionModelSourceModelFKey_Name, self.owner.PrimaryKeyValue);
-        });
-        if (this.Driver.Options.Database) {
-            query.database(this.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 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);
-    }
-}
-export class OneToManyRelationList extends Relation {
-    async deleteRelationData(data) {
-        if (data.length === 0) {
-            return;
-        }
-        const self = this;
-        const query = this.Driver.del()
-            .from(this.TargetModelDescriptor.TableName)
-            .andWhere(function () {
-            this.whereNotIn(self.Relation.PrimaryKey, data.filter((x) => x.PrimaryKeyValue).map((x) => x.PrimaryKeyValue));
-            this.where(self.Relation.ForeignKey, self.owner.PrimaryKeyValue);
-        });
-        if (this.Driver.Options.Database) {
-            query.database(this.Driver.Options.Database);
-        }
-        await query;
-        this.empty();
-    }
-    async diff(dataset, callback) {
-        // calculate difference between this data in relation and dataset ( objects from this relation)
-        const result = callback ? _.differenceWith(dataset, [...this], callback) : _.differenceBy(dataset, [...this], this.TargetModelDescriptor.PrimaryKey);
-        // calculate difference between dataset and data in this relation ( objects from dataset )
-        const result2 = callback ? _.differenceWith([...this], dataset, callback) : _.differenceBy([...this], dataset, this.TargetModelDescriptor.PrimaryKey);
-        // combine difference from two sets
-        const finalDiff = [...result, ...result2];
-        await this.deleteRelationData(finalDiff);
-        await this.add(finalDiff, InsertBehaviour.InsertOrUpdate);
-    }
-    async set(obj) {
-        await this.deleteRelationData(obj);
-        await this.add(obj, InsertBehaviour.InsertOrUpdate);
-    }
-    async intersection(obj, callback) {
-        const result = callback ? _.intersectionWith(obj, [...this], callback) : _.intersectionBy(obj, [...this], this.TargetModelDescriptor.PrimaryKey);
-        await this.deleteRelationData(result);
-        await this.add(result, InsertBehaviour.InsertOrUpdate);
-    }
-    async union(obj, mode) {
-        await this.add(obj, mode ?? InsertBehaviour.InsertOrIgnore);
-    }
-    async remove(obj) {
-        const data = (Array.isArray(obj) ? obj : [obj]).map((d) => d.PrimaryKeyValue);
-        const query = this.Driver.del().whereIn(this.Relation.ForeignKey, data).setTable(this.TargetModelDescriptor.TableName);
-        if (this.Driver.Options.Database) {
-            query.database(this.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 ModelBase) {
-                return x;
-            }
-            if (this.IsModelAForwardRef) {
-                new (this.Model())(x);
-            }
-            return new this.Model(x);
-        });
-        data.forEach((d) => {
-            d[this.Relation.ForeignKey] = this.owner.PrimaryKeyValue;
-        });
-        for (const m of tInsert) {
-            await m.insertOrUpdate(mode);
-        }
-        this.push(...tInsert);
-    }
-}
 //# sourceMappingURL=relations.js.map