@goatlab/fluent 0.6.18 → 0.6.19

package/dist/BaseConnector.d.ts

@@ -1,10 +1,11 @@
 import { TypedPathWrapper } from 'typed-path';
-import { Filter, DaoOutput, BaseDaoExtendedAttributes, LogicOperator, Primitives, PrimitivesArray } from './types';
 import { Collection } from '@goatlab/js-utils';
+import { Filter, DaoOutput, BaseDaoExtendedAttributes, LogicOperator, Primitives, PrimitivesArray } from './types';
 export interface FluentConnectorInterface<InputDTO, OutputDTO> {
     get(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     all(filter: Filter): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     findById(id: string): Promise<DaoOutput<InputDTO, OutputDTO>>;
+    findByIds(id: string[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     find(filter: Filter): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     deleteById(id: string): Promise<string>;
     updateById(id: string, data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
@@ -12,7 +13,7 @@ export interface FluentConnectorInterface<InputDTO, OutputDTO> {
     insertMany(data: InputDTO[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
 }
 export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
-    _keys: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never> & {
+    generatedKeyPath: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never> & {
         $path: (path: import("typed-path").TypedPathKey[]) => string;
         $raw: (path: import("typed-path").TypedPathKey[]) => string[];
         $rawPath: (path: import("typed-path").TypedPathKey[]) => import("typed-path").TypedPathKey[];
@@ -43,24 +44,26 @@ export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
     isMongoDB: boolean;
     protected getExtendedCreateAttributes: () => BaseDaoExtendedAttributes;
     constructor();
+    findByIds(ids: string[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     get(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     insertMany(data: InputDTO[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    updateById(id: string, data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>>;
     owner(user: string): this;
     own(user: string): this;
     first(): Promise<DaoOutput<InputDTO, OutputDTO> | null>;
     collect(): Promise<Collection<DaoOutput<InputDTO, OutputDTO>>>;
-    select(...columns: TypedPathWrapper<Primitives, Primitives>[]): this;
-    forceSelect(...columns: TypedPathWrapper<Primitives, Primitives>[]): this;
+    select(paths: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>>[] | TypedPathWrapper<string[], Record<never, never>[]>): this;
+    forceSelect(paths: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>>[] | TypedPathWrapper<string[], Record<never, never>[]>): this;
     offset(offset: number): this;
     populate(...relations: any[]): this;
     skip(offset: number): this;
-    where(path: TypedPathWrapper<Primitives, Primitives>, operator: LogicOperator, value: Primitives | PrimitivesArray): this;
-    andWhere(path: TypedPathWrapper<Primitives, Primitives>, operator: LogicOperator, value: Primitives | Primitives[]): this;
-    orWhere(path: TypedPathWrapper<Primitives, Primitives>, operator: LogicOperator, value: Primitives): this;
+    where(path: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>> | TypedPathWrapper<string[], Record<never, never>>, operator: LogicOperator, value: Primitives | PrimitivesArray): this;
+    andWhere(path: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>> | TypedPathWrapper<string[], Record<never, never>>, operator: LogicOperator, value: Primitives | Primitives[]): this;
+    orWhere(path: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>> | TypedPathWrapper<string[], Record<never, never>>, operator: LogicOperator, value: Primitives): this;
     limit(limit: number): this;
     take(limit: number): this;
-    pluck(path: TypedPathWrapper<Primitives, Primitives>): Promise<string[]>;
-    orderBy(path: TypedPathWrapper<Primitives, Primitives>, order?: 'asc' | 'desc', orderType?: 'string' | 'number' | 'date'): this;
+    pluck(path: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>> | TypedPathWrapper<string[], Record<never, never>>): Promise<string[]>;
+    orderBy(path: (p: TypedPathWrapper<ModelDTO & InputDTO & OutputDTO, Record<never, never>>) => TypedPathWrapper<string, Record<never, never>> | TypedPathWrapper<string[], Record<never, never>>, order?: 'asc' | 'desc', orderType?: 'string' | 'number' | 'date'): this;
     protected jsApplySelect(data: any): any[];
     protected jsApplyOrderBy(data: any): any[];
     protected reset(): void;
@@ -68,12 +71,13 @@ export declare abstract class BaseConnector<ModelDTO, InputDTO, OutputDTO> {
     loadFirst(): Promise<this>;
     getLoadedData(): DaoOutput<InputDTO, OutputDTO>[] | DaoOutput<InputDTO, OutputDTO>;
     with(entities: any): this;
-    attach(data: InputDTO): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
+    attach(data: InputDTO | DaoOutput<InputDTO, OutputDTO>): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     associate(id: string): any;
     protected hasMany<T>(Repository: any, relationName: string): T;
     protected hasOne(): void;
     protected belongsTo<T>(Repository: any, relationName: string): T;
     protected belongsToMany<T, R>(Repository: any, Pivot: any, relationName: string): T;
+    withPivot(): this;
     protected hasManyThrough(): void;
     private prepareInput;
 }

package/dist/BaseConnector.js

@@ -6,7 +6,7 @@ const dates_1 = require("@goatlab/dates");
 const js_utils_1 = require("@goatlab/js-utils");
 class BaseConnector {
     constructor() {
-        this._keys = (0, typed_path_1.typedPath)();
+        this.generatedKeyPath = (0, typed_path_1.typedPath)();
         this.chainReference = [];
         this.whereArray = [];
         this.orWhereArray = [];
@@ -50,12 +50,18 @@ class BaseConnector {
         this.outputKeys = [];
         this.getFirst = false;
     }
+    async findByIds(ids) {
+        throw new Error('findByIds() method not implemented');
+    }
     async get() {
         throw new Error('get() method not implemented');
     }
     async insertMany(data) {
         throw new Error('get() method not implemented');
     }
+    async updateById(id, data) {
+        throw new Error('get() method not implemented');
+    }
     owner(user) {
         this.chainReference.push({ method: 'owner', args: user });
         this.ownerId = user;
@@ -79,19 +85,23 @@ class BaseConnector {
         }
         return new js_utils_1.Collection(data);
     }
-    select(...columns) {
-        columns = this.prepareInput(columns);
+    select(paths) {
+        const arrCols = paths(this.generatedKeyPath);
+        const cols = arrCols.map(c => c.toString());
+        const columns = this.prepareInput(cols);
         this.chainReference.push({ method: 'select', args: columns });
         this.selectArray = this.selectArray
             .concat(columns)
             .filter((elem, pos, arr) => arr.indexOf(elem) === pos);
         return this;
     }
-    forceSelect(...columns) {
+    forceSelect(paths) {
         if (typeof module === 'undefined' || !module.exports) {
             throw new Error('forceSelect cant be used in frontend');
         }
-        columns = this.prepareInput(columns);
+        const arrCols = paths(this.generatedKeyPath);
+        const cols = arrCols.map(c => c.toString());
+        const columns = this.prepareInput(cols);
         this.chainReference.push({ method: 'forceSelect', args: columns });
         this.forceSelectArray = this.forceSelectArray
             .concat(columns)
@@ -112,7 +122,8 @@ class BaseConnector {
         return this.offset(offset);
     }
     where(path, operator, value) {
-        const stringPath = path.toString();
+        const stringP = path(this.generatedKeyPath);
+        const stringPath = stringP.toString();
         const chainedWhere = [stringPath, operator, value];
         this.chainReference.push({ method: 'where', chainedWhere });
         this.whereArray = [];
@@ -120,14 +131,16 @@ class BaseConnector {
         return this;
     }
     andWhere(path, operator, value) {
-        const stringPath = path.toString();
+        const stringP = path(this.generatedKeyPath);
+        const stringPath = stringP.toString();
         const chainedWhere = [stringPath, operator, value];
         this.chainReference.push({ method: 'andWhere', chainedWhere });
         this.whereArray.push(chainedWhere);
         return this;
     }
     orWhere(path, operator, value) {
-        const stringPath = path.toString();
+        const stringP = path(this.generatedKeyPath);
+        const stringPath = stringP.toString();
         const chainedWhere = [stringPath, operator, value];
         this.chainReference.push({ method: 'orWhere', chainedWhere });
         this.orWhereArray.push(chainedWhere);
@@ -142,7 +155,8 @@ class BaseConnector {
         return this.limit(limit);
     }
     async pluck(path) {
-        const stringPath = path.toString();
+        const stringP = path(this.generatedKeyPath);
+        const stringPath = stringP.toString();
         this.chainReference.push({ method: 'pluck', args: stringPath });
         const data = await this.get();
         const result = data.map(e => {
@@ -154,7 +168,8 @@ class BaseConnector {
         return result;
     }
     orderBy(path, order = 'desc', orderType = 'string') {
-        const stringPath = path.toString();
+        const stringP = path(this.generatedKeyPath);
+        const stringPath = stringP.toString();
         const orderB = [stringPath, order, orderType];
         this.chainReference.push({ method: 'orderBy', orderB });
         this.orderByArray = orderB;
@@ -279,39 +294,53 @@ class BaseConnector {
         if (!this.relationQuery.relation || !this.relationQuery.data) {
             throw new Error('Attached can only be called as a related model');
         }
-        if (this.relationQuery && this.relationQuery.data) {
-            const D = Array.isArray(this.relationQuery.data)
-                ? this.relationQuery.data
-                : [this.relationQuery.data];
-            const relatedData = D.map(d => ({
-                [this.relationQuery.relation.inverseSidePropertyPath]: this.isMongoDB
-                    ? js_utils_1.Ids.objectID(d.id)
-                    : d.id,
-                ...data
-            }));
-            return await this.insertMany(relatedData);
+        const foreignKeyName = this.relationQuery.relation.inverseSidePropertyPath;
+        const D = Array.isArray(this.relationQuery.data)
+            ? this.relationQuery.data
+            : [this.relationQuery.data];
+        const relatedData = D.map(d => ({
+            [foreignKeyName]: this.isMongoDB
+                ? js_utils_1.Ids.objectID(d.id)
+                : d.id,
+            ...data
+        }));
+        const existingData = await this.findByIds(relatedData.map(r => r.id));
+        const updateQueries = [];
+        const insertQueries = [];
+        for (const related of relatedData) {
+            const exists = existingData.find(d => d.id === related.id);
+            if (exists) {
+                updateQueries.push(this.updateById(exists.id, {
+                    ...exists,
+                    [foreignKeyName]: related[foreignKeyName]
+                }));
+            }
+            else {
+                insertQueries.push(related);
+            }
         }
+        const updateResult = await Promise.all(updateQueries);
+        const insertedResult = await this.insertMany(insertQueries);
+        return [...updateResult, ...insertedResult];
     }
     associate(id) {
-        if (!this.relationQuery.relation || !this.relationQuery.data) {
-            throw new Error('Attached can only be called as a related model');
-        }
-        if (this.relationQuery && this.relationQuery.data) {
-            const D = Array.isArray(this.relationQuery.data)
-                ? this.relationQuery.data
-                : [this.relationQuery.data];
-            const relatedData = D.map(d => ({
-                [this.relationQuery.relation.joinColumns[0].propertyName]: this
-                    .isMongoDB
-                    ? js_utils_1.Ids.objectID(d.id)
-                    : d.id,
-                [this.relationQuery.relation.inverseJoinColumns[0].propertyName]: this
-                    .isMongoDB
-                    ? js_utils_1.Ids.objectID(id)
-                    : id
-            }));
-            return this.relationQuery.pivot.insertMany(relatedData);
+        if (!this.relationQuery?.relation || !this.relationQuery.data) {
+            throw new Error('Associate can only be called as a related model');
         }
+        const D = Array.isArray(this.relationQuery.data)
+            ? this.relationQuery.data
+            : [this.relationQuery.data];
+        const relatedData = D.map(d => ({
+            [this.relationQuery.relation.joinColumns[0].propertyName]: this
+                .isMongoDB
+                ? js_utils_1.Ids.objectID(d.id)
+                : d.id,
+            [this.relationQuery.relation.inverseJoinColumns[0].propertyName]: this
+                .isMongoDB
+                ? js_utils_1.Ids.objectID(id)
+                : id
+        }));
+        return this.relationQuery.pivot.insertMany(relatedData);
     }
     hasMany(Repository, relationName) {
         if (this.relationQuery) {
@@ -346,6 +375,12 @@ class BaseConnector {
         this.reset();
         return newClass;
     }
+    withPivot() {
+        if (this.relationQuery?.pivot) {
+            this.relationQuery.returnPivot = true;
+        }
+        return this;
+    }
     hasManyThrough() {
         throw new Error('Method not implemented');
     }

package/dist/TypeOrmConnector/TypeOrmConnector.d.ts

@@ -6,8 +6,8 @@ export declare const getRelations: (typeOrmRepo: any) => {
     relations: {};
 };
 export declare class TypeOrmConnector<ModelDTO = BaseDataElement, InputDTO = ModelDTO, OutputDTO = InputDTO> extends BaseConnector<ModelDTO, InputDTO, OutputDTO> implements FluentConnectorInterface<InputDTO, DaoOutput<InputDTO, OutputDTO>> {
-    private repository;
-    private dataSource;
+    private readonly repository;
+    private readonly dataSource;
     constructor(entity: any, dataSource: DataSource, relationQuery?: any);
     get(): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     getPaginated(): Promise<PaginatedData<DaoOutput<InputDTO, OutputDTO>>>;
@@ -22,6 +22,7 @@ export declare class TypeOrmConnector<ModelDTO = BaseDataElement, InputDTO = Mod
     clear({ sure }: Sure): Promise<boolean>;
     deleteById(id: string): Promise<string>;
     findById(id: string): Promise<DaoOutput<InputDTO, OutputDTO>>;
+    findByIds(ids: string[]): Promise<DaoOutput<InputDTO, OutputDTO>[]>;
     private getPage;
     private getPaginatorLimit;
     private getPopulate;

package/dist/TypeOrmConnector/TypeOrmConnector.js

@@ -11,7 +11,7 @@ const generatorDatasource_1 = require("../generatorDatasource");
 const getRelations = typeOrmRepo => {
     const relations = {};
     for (const relation of typeOrmRepo.metadata.relations) {
-        relations[relation.inverseEntityMetadata.givenTableName.toLowerCase()] = {
+        relations[relation.propertyName] = {
             isOneToMany: relation.isOneToMany,
             isManyToOne: relation.isManyToOne,
             isManyToMany: relation.isManyToMany,
@@ -140,7 +140,7 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
                 ...{ updated: new Date() }
             }
             : data;
-        const updated = await this.repository.update(id, dataToInsert);
+        await this.repository.update(id, dataToInsert);
         const dbResult = await this.repository.findBy({
             id: (0, typeorm_1.In)([parsedId])
         });
@@ -185,8 +185,7 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
         if (!sure || sure !== true) {
             throw new Error('Clear() method will delete everything!, you must set the "sure" parameter "clear({sure:true})" to continue');
         }
-        return;
-        const data = await this.repository.clear();
+        await this.repository.clear();
         this.reset();
         return true;
     }
@@ -194,7 +193,7 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
         const parsedId = this.isMongoDB
             ? new mongodb_1.ObjectId(id)
             : id;
-        const removed = this.repository.delete(parsedId);
+        await this.repository.delete(parsedId);
         this.reset();
         return id;
     }
@@ -209,6 +208,17 @@ class TypeOrmConnector extends BaseConnector_1.BaseConnector {
         this.reset();
         return result[0];
     }
+    async findByIds(ids) {
+        const parsedIds = [...ids];
+        if (this.isMongoDB) {
+            parsedIds.map(id => new mongodb_1.ObjectId(id));
+        }
+        const data = await this.repository.findBy({
+            id: (0, typeorm_1.In)(parsedIds)
+        });
+        const result = this.jsApplySelect(data);
+        return result;
+    }
     getPage() {
         const page = 'page=';
         if (this.paginator && this.paginator.page) {

package/dist/TypeOrmConnector/test/advanced/advancedTestSuite.js

@@ -48,48 +48,49 @@ const advancedTestSuite = Model => {
     });
     it('pluck() should return a single array', async () => {
         await insertTestData(Model);
-        const data = await Model.pluck(Model._keys.test);
+        const data = await Model.pluck(keys => keys.test);
         expect(typeof data[0]).toBe('boolean');
     });
     it('orderBy() should order results desc', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(Model._keys.test, Model._keys.nestedTest.b.c, Model._keys.order)
-            .orderBy(Model._keys.order, 'desc')
+        const forms = await Model.select(keys => [keys.test, keys.nestedTest.b.c, keys.order])
+            .orderBy(keys => keys.order, 'desc')
             .get();
         expect(forms[0].order).toBe(3);
         expect(forms[0].nestedTest.b.c).toBe(true);
     });
     it('orderBy() should order results asc', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(Model._keys.test, Model._keys.nestedTest.b.c, Model._keys.order)
-            .orderBy(Model._keys.order, 'asc')
+        const forms = await Model.select(keys => [keys.test, keys.nestedTest.b.c, keys.order])
+            .orderBy(keys => keys.order, 'asc')
             .get();
         expect(forms[0].order).toBe(1);
     });
     it('orderBy() should order by Dates with Select()', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(Model._keys.created, Model._keys.order)
-            .orderBy(Model._keys.created, 'asc', 'date')
+        const forms = await Model.select(keys => [keys.created, keys.order])
+            .orderBy(keys => keys.created, 'asc', 'date')
             .get();
         expect(forms[0].order).toBe(3);
     });
     it('orderBy() should order by Dates without Select()', async () => {
         await insertTestData(Model);
-        const forms = await Model.orderBy(Model._keys.created, 'asc', 'date').get();
+        const forms = await Model.orderBy(keys => keys.created, 'asc', 'date').get();
         expect(forms[0].order).toBe(3);
     });
     it('limit() should limit the amount of results', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(Model._keys.created, Model._keys.order)
-            .orderBy(Model._keys.created, 'asc', 'date')
+        const forms = await Model.select(keys => [keys.created, keys.order])
+            .orderBy(keys => keys.created, 'asc', 'date')
             .limit(2)
             .get();
+        console.log('FOOORMS LENGTH', forms[0]);
         expect(forms.length > 0).toBe(true);
         expect(forms.length <= 2).toBe(true);
     });
     it('offset() should start at the given position', async () => {
         await insertTestData(Model);
-        const forms = await Model.select(Model._keys.created, Model._keys.order)
+        const forms = await Model.select(keys => [keys.created, keys.order])
             .offset(1)
             .limit(1)
             .get();
@@ -97,7 +98,7 @@ const advancedTestSuite = Model => {
     });
     it('where() should filter the data', async () => {
         await insertTestData(Model);
-        const forms = await Model.where(Model._keys.nestedTest.c, '>=', 3).get();
+        const forms = await Model.where(keys => keys.nestedTest.c, '>=', 3).get();
         expect(forms.length > 0).toBe(true);
         forms.forEach(form => {
             expect(form.nestedTest.c >= 3).toBe(true);
@@ -105,8 +106,8 @@ const advancedTestSuite = Model => {
     });
     it('first() should take the first result from data', async () => {
         await insertTestData(Model);
-        const form = await Model.select(Model._keys.nestedTest.c, Model._keys.id)
-            .where(Model._keys.nestedTest.c, '>=', 3)
+        const form = await Model.select(keys => [keys.nestedTest.c, keys.id])
+            .where(keys => keys.nestedTest.c, '>=', 3)
             .first();
         expect(typeof form.nestedTest.c).toBe('number');
     });

package/dist/TypeOrmConnector/test/relations/relationsTestsSuite.d.ts

@@ -1 +1 @@
-export declare const relationsTestSuite: (Model: any, BelongsToModel: any, ManyToManyModel: any) => void;
+export declare const relationsTestSuite: (ModelF: any, BelongsToModelF: any, ManyToManyModelF: any) => void;

package/dist/TypeOrmConnector/test/relations/relationsTestsSuite.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.relationsTestSuite = void 0;
-const relationsTestSuite = (Model, BelongsToModel, ManyToManyModel) => {
+let Model;
+let BelongsToModel;
+let ManyToManyModel;
+const relationsTestSuite = (ModelF, BelongsToModelF, ManyToManyModelF) => {
     beforeAll(() => {
-        Model = new Model();
-        BelongsToModel = new BelongsToModel();
-        ManyToManyModel = new ManyToManyModel();
+        Model = new ModelF();
+        BelongsToModel = new BelongsToModelF();
+        ManyToManyModel = new ManyToManyModelF();
     });
     test('Attach - OneToMany - Should  insert data', async () => {
         const insertedUser = await Model.insert({
@@ -13,7 +16,7 @@ const relationsTestSuite = (Model, BelongsToModel, ManyToManyModel) => {
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user = await Model.where(Model.cars()._keys.id, '=', insertedUser.id).load();
+        const user = await Model.where(keys => keys.id, '=', insertedUser.id).load();
         const cars = await user.cars().attach({ name: 'Another new car' });
         expect(Array.isArray(cars)).toBe(true);
         expect(cars[0].name).toBe('Another new car');
@@ -24,36 +27,36 @@ const relationsTestSuite = (Model, BelongsToModel, ManyToManyModel) => {
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user1 = await Model.where(Model._keys.id, '=', insertedUser.id).load();
+        const user1 = await Model.where(keys => keys.id, '=', insertedUser.id).load();
         const cars = await user1.cars().attach({ name: 'My new car' });
         expect(Array.isArray(cars)).toBe(true);
-        const searchUserWithRelation = await Model.where(Model._keys.id, '=', insertedUser.id)
-            .with({ cars: true })
+        const searchUserWithRelation = await Model.where(keys => keys.id, '=', insertedUser.id)
+            .with({ cars: BelongsToModelF })
             .get();
         expect(Array.isArray(searchUserWithRelation[0].cars)).toBe(true);
         expect(searchUserWithRelation[0].cars.length > 0).toBe(true);
         const searchCar = await user1
             .cars()
-            .where(Model.cars()._keys.name, '=', 'My new car')
+            .where(keys => keys.name, '=', 'My new car')
             .get();
         expect(Array.isArray(searchCar)).toBe(true);
         expect(searchCar.length > 0).toBe(true);
         const searchCar2 = await user1
             .cars()
-            .where(Model.cars()._keys.name, '=', 'My.......')
+            .where(keys => keys.name, '=', 'My.......')
             .get();
         expect(Array.isArray(searchCar2)).toBe(true);
         expect(searchCar2.length === 0).toBe(true);
     });
-    test('Query related model - BelongsTo', async () => {
+    test('Query related model - BelongTo', async () => {
         const insertedUser = await Model.insert({
             name: 'testUser',
             age: 20
         });
         expect(typeof insertedUser.id).toBe('string');
-        const user1 = await Model.where(Model.cars()._keys.id, '=', insertedUser.id).load();
+        const user1 = await Model.where(keys => keys.id, '=', insertedUser.id).load();
         await user1.cars().attach({ name: 'My new car' });
-        const results = await BelongsToModel.with({ users: true }).get();
+        const results = await BelongsToModel.with({ user: ModelF }).get();
         expect(Array.isArray(results)).toBe(true);
         expect(results.length > 0).toBe(true);
         expect(typeof results[0].user.name).toBe('string');
@@ -67,21 +70,21 @@ const relationsTestSuite = (Model, BelongsToModel, ManyToManyModel) => {
         const adminRole = await ManyToManyModel.insert({
             name: 'Administrator'
         });
-        const user = await Model.where(Model._keys.id, '=', insertedUser.id).load();
+        const user = await Model.where(keys => keys.id, '=', insertedUser.id).load();
         const associated = await user.roles().associate(adminRole.id);
         expect(associated[0].userId).toBe(insertedUser.id);
         expect(associated[0].roleId).toBe(adminRole.id);
-        const searchUserWithRelation = await Model.where(Model._keys.id, '=', insertedUser.id)
+        const searchUserWithRelation = await Model.where(keys => keys.id, '=', insertedUser.id)
             .with({
-            roles: true
+            roles: ManyToManyModelF
         })
             .get();
         expect(Array.isArray(searchUserWithRelation[0].roles)).toBe(true);
         expect(searchUserWithRelation[0].roles.length > 0).toBe(true);
         expect(typeof searchUserWithRelation[0].roles[0].name).toBe('string');
-        const roles = await ManyToManyModel.where(ManyToManyModel._keys.name, '=', 'Administrator')
+        const roles = await ManyToManyModel.where(keys => keys.name, '=', 'Administrator')
             .with({
-            users: true
+            users: ModelF
         })
             .get();
         expect(Array.isArray(roles)).toBe(true);

package/dist/loadRelations.d.ts

@@ -6,6 +6,7 @@ interface RelationshipLoader {
     dataSource?: DataSource;
     provider?: 'typeorm' | 'firebase';
     self: any;
+    returnPivot?: boolean;
 }
-export declare const loadRelations: ({ data, relations, modelRelations, dataSource, provider, self }: RelationshipLoader) => Promise<any[]>;
+export declare const loadRelations: ({ data, relations, modelRelations, provider, self, returnPivot }: RelationshipLoader) => Promise<any[]>;
 export {};

package/dist/loadRelations.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadRelations = void 0;
 const js_utils_1 = require("@goatlab/js-utils");
-const loadRelations = async ({ data, relations, modelRelations, dataSource, provider, self }) => {
+const loadRelations = async ({ data, relations, modelRelations, provider, self, returnPivot }) => {
     if (!relations) {
         return data;
     }
@@ -12,11 +12,11 @@ const loadRelations = async ({ data, relations, modelRelations, dataSource, prov
             const relationModel = modelRelations[relation];
             const Model = new relations[relation]();
             if (relationModel.isOneToMany) {
-                const ids = js_utils_1.Arrays.deDuplicate(data.map(d => Model.isMongoDB ? js_utils_1.Ids.objectID(d.id) : d.id));
-                const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
+                const ids = new Set(data.map(d => Model.isMongoDB ? js_utils_1.Ids.objectID(d.id) : d.id));
+                const chunks = js_utils_1.Arrays.chunk(Array.from(ids), chunkSize);
                 const promises = [];
                 for (const relatedIds of chunks) {
-                    const results = await Model.andWhere(Model._keys[relationModel.inverseSidePropertyPath], 'in', relatedIds).get();
+                    const results = await Model.andWhere(keys => keys[relationModel.inverseSidePropertyPath], 'in', relatedIds).get();
                     promises.push(results);
                 }
                 const relatedResults = js_utils_1.Arrays.collapse(await Promise.all(promises));
@@ -32,7 +32,7 @@ const loadRelations = async ({ data, relations, modelRelations, dataSource, prov
                 const chunks = js_utils_1.Arrays.chunk(ids, chunkSize);
                 const promises = [];
                 for (const relatedIds of chunks) {
-                    const results = await Model.andWhere(Model._keys.id, 'in', relatedIds).get();
+                    const results = await Model.andWhere(keys => keys.id, 'in', relatedIds).get();
                     promises.push(results);
                 }
                 const relatedResults = js_utils_1.Arrays.collapse(promises);
@@ -54,7 +54,7 @@ const loadRelations = async ({ data, relations, modelRelations, dataSource, prov
                 const promises = [];
                 for (const pivotIds of chunks) {
                     const results = await pivotRepository
-                        .where(relationModel.joinColumns[0].propertyName, 'in', pivotIds)
+                        .where(k => k[relationModel.joinColumns[0].propertyName], 'in', pivotIds)
                         .get();
                     promises.push(results);
                 }
@@ -63,10 +63,14 @@ const loadRelations = async ({ data, relations, modelRelations, dataSource, prov
                 const relationChunks = js_utils_1.Arrays.chunk(uniquePivotIds, chunkSize);
                 const relationPromises = [];
                 for (const relatedIds of relationChunks) {
-                    const results = await Model.andWhere(Model._keys.id, 'in', relatedIds).get();
+                    const results = await Model.andWhere(keys => keys.id, 'in', relatedIds).get();
                     relationPromises.push(results);
                 }
-                const relatedResults = js_utils_1.Arrays.collapse(await Promise.all(relationPromises));
+                let relatedResults = js_utils_1.Arrays.collapse(await Promise.all(relationPromises));
+                const pivotInverseKey = relationModel.inverseJoinColumns[0].propertyName;
+                relatedResults = relatedResults.map(r => {
+                    return { ...r, pivot: pivotResults.find(p => p[pivotInverseKey] === r.id) };
+                });
                 const groupedPivot = js_utils_1.Arrays.groupBy(pivotResults, r => r[relationModel.joinColumns[0].propertyName]);
                 const groupedRelated = js_utils_1.Arrays.groupBy(relatedResults, r => r.id);
                 data.forEach(d => {