@spinajs/orm 2.0.180 → 2.0.182

package/lib/mjs/relation-objects.js

@@ -1,212 +1,212 @@
-/* eslint-disable prettier/prettier */
-import { InsertBehaviour } from './interfaces.js';
-import { DI, isConstructor } from '@spinajs/di';
-import { SelectQueryBuilder } from './builders.js';
-import { createQuery, extractModelDescriptor, ModelBase } from './model.js';
-import { Orm } from './orm.js';
-import _ from 'lodash';
-/**
- * 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 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;
-    }
-}
-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);
-    }
-}
+/* eslint-disable prettier/prettier */
+import { InsertBehaviour } from './interfaces.js';
+import { DI, isConstructor } from '@spinajs/di';
+import { SelectQueryBuilder } from './builders.js';
+import { createQuery, extractModelDescriptor, ModelBase } from './model.js';
+import { Orm } from './orm.js';
+import _ from 'lodash';
+/**
+ * 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 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;
+    }
+}
+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=relation-objects.js.map

package/lib/mjs/relations.d.ts

@@ -1,62 +1,62 @@
-import { IRelationDescriptor, IModelDescriptor, ForwardRefFunction, ISelectQueryBuilder } from './interfaces.js';
-import { Constructor, Container } from '@spinajs/di';
-import { ModelBase } from './model.js';
-import { Orm } from './orm.js';
-import { OrmDriver } from './driver.js';
-export interface IOrmRelation {
-    /**
-     * Executes relation, should be called only once.
-     *
-     * @param callback - optional callback to perform actions on relations eg. populate more, filter relational data etc.
-     */
-    execute(callback?: (this: ISelectQueryBuilder, relation: OrmRelation) => void): void;
-    /**
-     * Execute actions on relation query, does not initialize relation. Use it only AFTER execute was called.
-     *
-     * @param callback - execute callback to perform actions on relations eg. populate more, filter relational data etc.
-     */
-    executeOnQuery(callback: (this: ISelectQueryBuilder, relation: OrmRelation) => void): void;
-    /**
-     * Relation name
-     */
-    Name: string;
-}
-export declare abstract class OrmRelation implements IOrmRelation {
-    protected _container: Container;
-    protected _query: ISelectQueryBuilder;
-    protected _description: IRelationDescriptor;
-    parentRelation?: OrmRelation;
-    protected _targetModel: Constructor<ModelBase> | ForwardRefFunction;
-    protected _targetModelDescriptor: IModelDescriptor;
-    protected _relationQuery: ISelectQueryBuilder;
-    protected _separator: string;
-    protected _driver: OrmDriver;
-    Name: string;
-    get Alias(): string;
-    constructor(_container: Container, _query: ISelectQueryBuilder, _description: IRelationDescriptor, parentRelation?: OrmRelation);
-    abstract execute(callback?: (this: ISelectQueryBuilder, relation: OrmRelation) => void): void;
-    executeOnQuery(callback: (this: ISelectQueryBuilder<any>, relation: OrmRelation) => void): void;
-}
-export declare class BelongsToRelation extends OrmRelation {
-    constructor(_container: Container, _query: ISelectQueryBuilder<any>, _description: IRelationDescriptor, _parentRelation?: OrmRelation);
-    execute(callback: (this: ISelectQueryBuilder, relation: OrmRelation) => void): void;
-}
-export declare class BelongsToRecursiveRelation extends OrmRelation {
-    constructor(_container: Container, _query: ISelectQueryBuilder<any>, _description: IRelationDescriptor, _parentRelation?: OrmRelation);
-    execute(callback: (this: ISelectQueryBuilder, relation: OrmRelation) => void): void;
-}
-export declare class OneToManyRelation extends OrmRelation {
-    constructor(_container: Container, _query: ISelectQueryBuilder<any>, _description: IRelationDescriptor, _parentRelation?: OrmRelation);
-    execute(callback?: (this: ISelectQueryBuilder<any>, relation: OrmRelation) => void): void;
-}
-export declare class ManyToManyRelation extends OrmRelation {
-    protected _orm: Orm;
-    protected _joinModel: Constructor<ModelBase>;
-    protected _joinModelDescriptor: IModelDescriptor;
-    protected _joinQuery: ISelectQueryBuilder;
-    get TableJoinQuery(): ISelectQueryBuilder<unknown>;
-    get RelationQuery(): ISelectQueryBuilder<unknown>;
-    constructor(_container: Container, _orm: Orm, _query: ISelectQueryBuilder<any>, _description: IRelationDescriptor, _parentRelation?: OrmRelation);
-    execute(callback?: (this: ISelectQueryBuilder<any>, relation: OrmRelation) => void): void;
-}
+import { IRelationDescriptor, IModelDescriptor, ForwardRefFunction, ISelectQueryBuilder } from './interfaces.js';
+import { Constructor, Container } from '@spinajs/di';
+import { ModelBase } from './model.js';
+import { Orm } from './orm.js';
+import { OrmDriver } from './driver.js';
+export interface IOrmRelation {
+    /**
+     * Executes relation, should be called only once.
+     *
+     * @param callback - optional callback to perform actions on relations eg. populate more, filter relational data etc.
+     */
+    execute(callback?: (this: ISelectQueryBuilder, relation: OrmRelation) => void): void;
+    /**
+     * Execute actions on relation query, does not initialize relation. Use it only AFTER execute was called.
+     *
+     * @param callback - execute callback to perform actions on relations eg. populate more, filter relational data etc.
+     */
+    executeOnQuery(callback: (this: ISelectQueryBuilder, relation: OrmRelation) => void): void;
+    /**
+     * Relation name
+     */
+    Name: string;
+}
+export declare abstract class OrmRelation implements IOrmRelation {
+    protected _container: Container;
+    protected _query: ISelectQueryBuilder;
+    protected _description: IRelationDescriptor;
+    parentRelation?: OrmRelation;
+    protected _targetModel: Constructor<ModelBase> | ForwardRefFunction;
+    protected _targetModelDescriptor: IModelDescriptor;
+    protected _relationQuery: ISelectQueryBuilder;
+    protected _separator: string;
+    protected _driver: OrmDriver;
+    Name: string;
+    get Alias(): string;
+    constructor(_container: Container, _query: ISelectQueryBuilder, _description: IRelationDescriptor, parentRelation?: OrmRelation);
+    abstract execute(callback?: (this: ISelectQueryBuilder, relation: OrmRelation) => void): void;
+    executeOnQuery(callback: (this: ISelectQueryBuilder<any>, relation: OrmRelation) => void): void;
+}
+export declare class BelongsToRelation extends OrmRelation {
+    constructor(_container: Container, _query: ISelectQueryBuilder<any>, _description: IRelationDescriptor, _parentRelation?: OrmRelation);
+    execute(callback: (this: ISelectQueryBuilder, relation: OrmRelation) => void): void;
+}
+export declare class BelongsToRecursiveRelation extends OrmRelation {
+    constructor(_container: Container, _query: ISelectQueryBuilder<any>, _description: IRelationDescriptor, _parentRelation?: OrmRelation);
+    execute(callback: (this: ISelectQueryBuilder, relation: OrmRelation) => void): void;
+}
+export declare class OneToManyRelation extends OrmRelation {
+    constructor(_container: Container, _query: ISelectQueryBuilder<any>, _description: IRelationDescriptor, _parentRelation?: OrmRelation);
+    execute(callback?: (this: ISelectQueryBuilder<any>, relation: OrmRelation) => void): void;
+}
+export declare class ManyToManyRelation extends OrmRelation {
+    protected _orm: Orm;
+    protected _joinModel: Constructor<ModelBase>;
+    protected _joinModelDescriptor: IModelDescriptor;
+    protected _joinQuery: ISelectQueryBuilder;
+    get TableJoinQuery(): ISelectQueryBuilder<unknown>;
+    get RelationQuery(): ISelectQueryBuilder<unknown>;
+    constructor(_container: Container, _orm: Orm, _query: ISelectQueryBuilder<any>, _description: IRelationDescriptor, _parentRelation?: OrmRelation);
+    execute(callback?: (this: ISelectQueryBuilder<any>, relation: OrmRelation) => void): void;
+}
 //# sourceMappingURL=relations.d.ts.map