drizzle-orm 0.9.18 → 0.10.2

package/builders/joinBuilders/builders/selectWithFiveJoins.d.ts

@@ -3,21 +3,33 @@ import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import { ISession } from '../../../db/session';
 import { AbstractTable } from '../../../tables';
+import { PartialFor } from '../../../tables/inferTypes';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
 import Join from '../join';
 import SelectResponseFiveJoins from '../responses/selectResponseFiveJoins';
 import AbstractJoined from './abstractJoinBuilder';
-export default class SelectTRBWithFiveJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2, TTable3, TTable4, TTable5> extends AbstractJoined<TTable, SelectResponseFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, TTable5>> {
+export default class SelectTRBWithFiveJoins<TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>, TTable3 extends AbstractTable<TTable3>, TTable4 extends AbstractTable<TTable4>, TTable5 extends AbstractTable<TTable5>, TPartial extends PartialFor<TTable> = {}, TPartial1 extends PartialFor<TTable1> = {}, TPartial2 extends PartialFor<TTable2> = {}, TPartial3 extends PartialFor<TTable3> = {}, TPartial4 extends PartialFor<TTable4> = {}, TPartial5 extends PartialFor<TTable5> = {}> extends AbstractJoined<TTable, SelectResponseFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, TTable5, TPartial, TPartial1, TPartial2, TPartial3, TPartial4, TPartial5>, TPartial> {
     private _join1;
     private _join2;
     private _join3;
     private _join4;
     private _join5;
+    private _joinedPartial?;
+    private _joinedPartial1?;
+    private _joinedPartial2?;
+    private _joinedPartial3?;
+    private _joinedPartial4?;
     constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, join5: Join<TTable5>, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);
-    protected joins(): Join<any>[];
-    protected mapResponse(result: QueryResult<any>): SelectResponseFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, TTable5>;
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3, joinedPartial3?: TPartial4, joinedPartial4?: TPartial5);
+    protected joins(): Array<{
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        };
+        id?: number;
+    }>;
+    protected mapResponse(result: QueryResult<any>): SelectResponseFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, TTable5, TPartial, TPartial1, TPartial2, TPartial3, TPartial4, TPartial5>;
 }

package/builders/joinBuilders/builders/selectWithFiveJoins.js

@@ -1,19 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const responseMapper_1 = require("../../../mappers/responseMapper");
 const selectResponseFiveJoins_1 = require("../responses/selectResponseFiveJoins");
 const abstractJoinBuilder_1 = require("./abstractJoinBuilder");
 class SelectTRBWithFiveJoins extends abstractJoinBuilder_1.default {
-    constructor(table, session, filter, join1, join2, join3, join4, join5, props, orderBy, order, distinct) {
-        super(table, filter, session, props, orderBy, order, distinct);
+    constructor(table, session, filter, join1, join2, join3, join4, join5, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1, joinedPartial2, joinedPartial3, joinedPartial4) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
         this._join1 = join1;
         this._join2 = join2;
         this._join3 = join3;
         this._join4 = join4;
         this._join5 = join5;
+        this._joinedPartial = joinedPartial;
+        this._joinedPartial1 = joinedPartial1;
+        this._joinedPartial2 = joinedPartial2;
+        this._joinedPartial3 = joinedPartial3;
+        this._joinedPartial4 = joinedPartial4;
     }
     joins() {
-        return [this._join1, this._join2, this._join3, this._join4, this._join5];
+        return [{ join: this._join1, partial: this._joinedPartial, id: 1 },
+            { join: this._join2, partial: this._joinedPartial1, id: 2 },
+            { join: this._join3, partial: this._joinedPartial2, id: 3 },
+            { join: this._join4, partial: this._joinedPartial3, id: 4 },
+            { join: this._join5, partial: this._joinedPartial4, id: 5 }];
     }
     mapResponse(result) {
         const parent = this._join1.mappedServiceToDb;
@@ -21,12 +29,13 @@ class SelectTRBWithFiveJoins extends abstractJoinBuilder_1.default {
         const parentThree = this._join3.mappedServiceToDb;
         const parentFour = this._join4.mappedServiceToDb;
         const parentFive = this._join5.mappedServiceToDb;
-        const response = responseMapper_1.default.map(this._table.mapServiceToDb(), result);
-        const objects = responseMapper_1.default.map(parent, result);
-        const objectsTwo = responseMapper_1.default.map(parentTwo, result);
-        const objectsThree = responseMapper_1.default.map(parentThree, result);
-        const objectsFour = responseMapper_1.default.map(parentFour, result);
-        const objectsFive = responseMapper_1.default.map(parentFive, result);
+        // TODO map ids for join properly
+        const response = this.fullOrPartial(this._table.mapServiceToDb(), result, this._partial);
+        const objects = this.fullOrPartial(parent, result, this._joinedPartial, 1);
+        const objectsTwo = this.fullOrPartial(parentTwo, result, this._joinedPartial1, 2);
+        const objectsThree = this.fullOrPartial(parentThree, result, this._joinedPartial2, 3);
+        const objectsFour = this.fullOrPartial(parentFour, result, this._joinedPartial3, 4);
+        const objectsFive = this.fullOrPartial(parentFive, result, this._joinedPartial4, 5);
         return new selectResponseFiveJoins_1.default(response, objects, objectsTwo, objectsThree, objectsFour, objectsFive);
     }
 }

package/builders/joinBuilders/builders/selectWithFourJoins.d.ts

@@ -4,33 +4,52 @@ import ColumnType from '../../../columns/types/columnType';
 import DB from '../../../db/db';
 import { ISession } from '../../../db/session';
 import { AbstractTable } from '../../../tables';
+import { CheckFiveTypes, PartialFor } from '../../../tables/inferTypes';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
 import Join from '../join';
 import SelectResponseFourJoins from '../responses/selectResponseFourJoins';
 import AbstractJoined from './abstractJoinBuilder';
 import SelectTRBWithFiveJoins from './selectWithFiveJoins';
-export default class SelectTRBWithFourJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2, TTable3, TTable4> extends AbstractJoined<TTable, SelectResponseFourJoins<TTable, TTable1, TTable2, TTable3, TTable4>> {
+export default class SelectTRBWithFourJoins<TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>, TTable3 extends AbstractTable<TTable3>, TTable4 extends AbstractTable<TTable4>, TPartial extends PartialFor<TTable> = {}, TPartial1 extends PartialFor<TTable1> = {}, TPartial2 extends PartialFor<TTable2> = {}, TPartial3 extends PartialFor<TTable3> = {}, TPartial4 extends PartialFor<TTable4> = {}> extends AbstractJoined<TTable, SelectResponseFourJoins<TTable, TTable1, TTable2, TTable3, TTable4, TPartial, TPartial1, TPartial2, TPartial3, TPartial4>, TPartial> {
     private _join1;
     private _join2;
     private _join3;
     private _join4;
+    private _joinedPartial?;
+    private _joinedPartial1?;
+    private _joinedPartial2?;
+    private _joinedPartial3?;
     constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);
-    innerJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3, joinedPartial3?: TPartial4);
+    innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable>;
-    leftJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>) => AbstractColumn<TColumn, boolean, boolean, CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable, TPartial, TPartial1, TPartial2, TPartial3, TPartial4, IToPartial>;
+    leftJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable>;
-    rightJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>) => AbstractColumn<TColumn, boolean, boolean, CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable, TPartial, TPartial1, TPartial2, TPartial3, TPartial4, IToPartial>;
+    rightJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable>;
-    fullJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>) => AbstractColumn<TColumn, boolean, boolean, CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable, TPartial, TPartial1, TPartial2, TPartial3, TPartial4, IToPartial>;
+    fullJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn>, to: (table: IToTable) => AbstractColumn<TColumn>): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable>;
-    protected joins(): Join<any>[];
-    protected mapResponse(result: QueryResult<any>): SelectResponseFourJoins<TTable, TTable1, TTable2, TTable3, TTable4>;
+    }, from: (table: CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>) => AbstractColumn<TColumn, boolean, boolean, CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>>, to: (table: IToTable) => AbstractColumn<TColumn>, partial?: IToPartial): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable, TPartial, TPartial1, TPartial2, TPartial3, TPartial4, IToPartial>;
+    protected joins(): Array<{
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        };
+        id?: number;
+    }>;
+    protected mapResponse(result: QueryResult<any>): SelectResponseFourJoins<TTable, TTable1, TTable2, TTable3, TTable4, TPartial, TPartial1, TPartial2, TPartial3, TPartial4>;
 }

package/builders/joinBuilders/builders/selectWithFourJoins.js

@@ -1,64 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const responseMapper_1 = require("../../../mappers/responseMapper");
 const join_1 = require("../join");
 const joinWith_1 = require("../joinWith");
 const selectResponseFourJoins_1 = require("../responses/selectResponseFourJoins");
 const abstractJoinBuilder_1 = require("./abstractJoinBuilder");
 const selectWithFiveJoins_1 = require("./selectWithFiveJoins");
 class SelectTRBWithFourJoins extends abstractJoinBuilder_1.default {
-    constructor(table, session, filter, join1, join2, join3, join4, props, orderBy, order, distinct) {
-        super(table, filter, session, props, orderBy, order, distinct);
+    constructor(table, session, filter, join1, join2, join3, join4, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1, joinedPartial2, joinedPartial3) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
         this._join1 = join1;
         this._join2 = join2;
         this._join3 = join3;
         this._join4 = join4;
+        this._joinedPartial = joinedPartial;
+        this._joinedPartial1 = joinedPartial1;
+        this._joinedPartial2 = joinedPartial2;
+        this._joinedPartial3 = joinedPartial3;
     }
-    innerJoin(table, from, to) {
+    innerJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.INNER_JOIN);
-        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
     }
-    leftJoin(table, from, to) {
+    leftJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.LEFT_JOIN);
-        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
     }
-    rightJoin(table, from, to) {
+    rightJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.RIGHT_JOIN);
-        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
     }
-    fullJoin(table, from, to) {
+    fullJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.FULL_JOIN);
-        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
     }
     joins() {
-        return [this._join1, this._join2, this._join3, this._join4];
+        return [{ join: this._join1, partial: this._joinedPartial, id: 1 },
+            { join: this._join2, partial: this._joinedPartial1, id: 2 },
+            { join: this._join3, partial: this._joinedPartial2, id: 3 },
+            { join: this._join4, partial: this._joinedPartial3, id: 4 }];
     }
     mapResponse(result) {
         const parent = this._join1.mappedServiceToDb;
         const parentTwo = this._join2.mappedServiceToDb;
         const parentThree = this._join3.mappedServiceToDb;
         const parentFour = this._join4.mappedServiceToDb;
-        const response = responseMapper_1.default.map(this._table.mapServiceToDb(), result);
-        const objects = responseMapper_1.default.map(parent, result);
-        const objectsTwo = responseMapper_1.default.map(parentTwo, result);
-        const objectsThree = responseMapper_1.default.map(parentThree, result);
-        const objectsFour = responseMapper_1.default.map(parentFour, result);
+        const response = this.fullOrPartial(this._table.mapServiceToDb(), result, this._partial);
+        const objects = this.fullOrPartial(parent, result, this._joinedPartial, 1);
+        const objectsTwo = this.fullOrPartial(parentTwo, result, this._joinedPartial1, 2);
+        const objectsThree = this.fullOrPartial(parentThree, result, this._joinedPartial2, 3);
+        const objectsFour = this.fullOrPartial(parentFour, result, this._joinedPartial3, 4);
         return new selectResponseFourJoins_1.default(response, objects, objectsTwo, objectsThree, objectsFour);
     }
 }

package/builders/joinBuilders/builders/selectWithJoin.d.ts

@@ -4,30 +4,46 @@ import ColumnType from '../../../columns/types/columnType';
 import DB from '../../../db/db';
 import { ISession } from '../../../db/session';
 import AbstractTable from '../../../tables/abstractTable';
+import { CheckTwoTypes, PartialFor } from '../../../tables/inferTypes';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
 import Join from '../join';
 import SelectResponseJoin from '../responses/selectResponseWithJoin';
 import AbstractJoined from './abstractJoinBuilder';
 import SelectTRBWithTwoJoins from './selectWithTwoJoins';
-export default class SelectTRBWithJoin<TTable extends AbstractTable<TTable>, TTable1> extends AbstractJoined<TTable, SelectResponseJoin<TTable, TTable1>> {
+export default class SelectTRBWithJoin<TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>, TPartial extends PartialFor<TTable> = {}, TPartial1 extends PartialFor<TTable1> = {}> extends AbstractJoined<TTable, SelectResponseJoin<TTable, TTable1, TPartial, TPartial1>, TPartial> {
     private _join;
+    private _joinedPartial?;
     constructor(table: TTable, session: ISession, filter: Expr, join: Join<TTable1>, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);
-    innerJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1);
+    innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithTwoJoins<TTable, TTable1, IToTable>;
-    leftJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: CheckTwoTypes<InputTable, TTable, TTable1>) => AbstractColumn<TColumn, boolean, boolean, CheckTwoTypes<InputTable, TTable, TTable1>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithTwoJoins<TTable, TTable1, IToTable, TPartial, TPartial1, IToPartial>;
+    leftJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithTwoJoins<TTable, TTable1, IToTable>;
-    rightJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: CheckTwoTypes<InputTable, TTable, TTable1>) => AbstractColumn<TColumn, boolean, boolean, CheckTwoTypes<InputTable, TTable, TTable1>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithTwoJoins<TTable, TTable1, IToTable, TPartial, TPartial1, IToPartial>;
+    rightJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithTwoJoins<TTable, TTable1, IToTable>;
-    fullJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: CheckTwoTypes<InputTable, TTable, TTable1>) => AbstractColumn<TColumn, boolean, boolean, CheckTwoTypes<InputTable, TTable, TTable1>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithTwoJoins<TTable, TTable1, IToTable, TPartial, TPartial1, IToPartial>;
+    fullJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn>, to: (table: IToTable) => AbstractColumn<TColumn>): SelectTRBWithTwoJoins<TTable, TTable1, IToTable>;
-    protected joins(): Join<any>[];
-    protected mapResponse(result: QueryResult<any>): SelectResponseJoin<TTable, TTable1>;
+    }, from: (table: CheckTwoTypes<InputTable, TTable, TTable1>) => AbstractColumn<TColumn, boolean, boolean, CheckTwoTypes<InputTable, TTable, TTable1>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithTwoJoins<TTable, TTable1, IToTable, TPartial, TPartial1, IToPartial>;
+    protected joins(): Array<{
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        };
+        id?: number;
+    }>;
+    protected mapResponse(result: QueryResult<any>): SelectResponseJoin<TTable, TTable1, TPartial, TPartial1>;
 }

package/builders/joinBuilders/builders/selectWithJoin.js

@@ -1,55 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const responseMapper_1 = require("../../../mappers/responseMapper");
 const join_1 = require("../join");
 const joinWith_1 = require("../joinWith");
 const selectResponseWithJoin_1 = require("../responses/selectResponseWithJoin");
 const abstractJoinBuilder_1 = require("./abstractJoinBuilder");
 const selectWithTwoJoins_1 = require("./selectWithTwoJoins");
+// eslint-disable-next-line max-len
 class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
-    constructor(table, session, filter, join, props, orderBy, order, distinct) {
-        super(table, filter, session, props, orderBy, order, distinct);
+    constructor(table, session, filter, join, props, orderBy, order, distinct, tablePartial, joinedPartial) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
         this._join = join;
+        this._joinedPartial = joinedPartial;
     }
-    innerJoin(table, from, to) {
+    innerJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.INNER_JOIN);
-        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial);
     }
-    leftJoin(table, from, to) {
+    leftJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.LEFT_JOIN);
-        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial);
     }
-    rightJoin(table, from, to) {
+    rightJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.RIGHT_JOIN);
-        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial);
     }
-    fullJoin(table, from, to) {
+    fullJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.FULL_JOIN);
-        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial);
     }
     joins() {
-        return [this._join];
+        return [{ join: this._join, partial: this._joinedPartial, id: 1 }];
     }
     mapResponse(result) {
         const parent = this._join.mappedServiceToDb;
-        const response = responseMapper_1.default.map(this._table.mapServiceToDb(), result);
-        const objects = responseMapper_1.default.map(parent, result);
+        const response = this.fullOrPartial(this._table.mapServiceToDb(), result, this._partial);
+        const objects = this.fullOrPartial(parent, result, this._joinedPartial, 1);
         return new selectResponseWithJoin_1.default(response, objects);
     }
 }

package/builders/joinBuilders/builders/selectWithThreeJoins.d.ts

@@ -4,32 +4,50 @@ import ColumnType from '../../../columns/types/columnType';
 import DB from '../../../db/db';
 import { ISession } from '../../../db/session';
 import AbstractTable from '../../../tables/abstractTable';
+import { CheckFourTypes, PartialFor } from '../../../tables/inferTypes';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
 import Join from '../join';
 import SelectResponseThreeJoins from '../responses/selectResponseThreeJoins';
 import AbstractJoined from './abstractJoinBuilder';
 import SelectTRBWithFourJoins from './selectWithFourJoins';
-export default class SelectTRBWithThreeJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2, TTable3> extends AbstractJoined<TTable, SelectResponseThreeJoins<TTable, TTable1, TTable2, TTable3>> {
+export default class SelectTRBWithThreeJoins<TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>, TTable3 extends AbstractTable<TTable3>, TPartial extends PartialFor<TTable> = {}, TPartial1 extends PartialFor<TTable1> = {}, TPartial2 extends PartialFor<TTable2> = {}, TPartial3 extends PartialFor<TTable3> = {}> extends AbstractJoined<TTable, SelectResponseThreeJoins<TTable, TTable1, TTable2, TTable3, TPartial, TPartial1, TPartial2, TPartial3>, TPartial> {
     private _join1;
     private _join2;
     private _join3;
+    private _joinedPartial?;
+    private _joinedPartial1?;
+    private _joinedPartial2?;
     constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);
-    innerJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3);
+    innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable>;
-    leftJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>) => AbstractColumn<TColumn, boolean, boolean, CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable, TPartial, TPartial1, TPartial2, TPartial3, IToPartial>;
+    leftJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable>;
-    rightJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>) => AbstractColumn<TColumn, boolean, boolean, CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable, TPartial, TPartial1, TPartial2, TPartial3, IToPartial>;
+    rightJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable>;
-    fullJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>) => AbstractColumn<TColumn, boolean, boolean, CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable, TPartial, TPartial1, TPartial2, TPartial3, IToPartial>;
+    fullJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn>, to: (table: IToTable) => AbstractColumn<TColumn>): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable>;
-    protected mapResponse(result: QueryResult<any>): SelectResponseThreeJoins<TTable, TTable1, TTable2, TTable3>;
-    protected joins(): Join<any>[];
+    }, from: (table: CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>) => AbstractColumn<TColumn, boolean, boolean, CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable, TPartial, TPartial1, TPartial2, TPartial3, IToPartial>;
+    protected mapResponse(result: QueryResult<any>): SelectResponseThreeJoins<TTable, TTable1, TTable2, TTable3, TPartial, TPartial1, TPartial2, TPartial3>;
+    protected joins(): Array<{
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        };
+        id?: number;
+    }>;
 }

package/builders/joinBuilders/builders/selectWithThreeJoins.js

@@ -1,62 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const responseMapper_1 = require("../../../mappers/responseMapper");
 const join_1 = require("../join");
 const joinWith_1 = require("../joinWith");
 const selectResponseThreeJoins_1 = require("../responses/selectResponseThreeJoins");
 const abstractJoinBuilder_1 = require("./abstractJoinBuilder");
 const selectWithFourJoins_1 = require("./selectWithFourJoins");
 class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
-    constructor(table, session, filter, join1, join2, join3, props, orderBy, order, distinct) {
-        super(table, filter, session, props, orderBy, order, distinct);
+    constructor(table, session, filter, join1, join2, join3, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1, joinedPartial2) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
         this._join1 = join1;
         this._join2 = join2;
         this._join3 = join3;
+        this._joinedPartial = joinedPartial;
+        this._joinedPartial1 = joinedPartial1;
+        this._joinedPartial2 = joinedPartial2;
     }
-    innerJoin(table, from, to) {
+    innerJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.INNER_JOIN);
-        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
     }
-    leftJoin(table, from, to) {
+    leftJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.LEFT_JOIN);
-        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
     }
-    rightJoin(table, from, to) {
+    rightJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.RIGHT_JOIN);
-        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
     }
-    fullJoin(table, from, to) {
+    fullJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.FULL_JOIN);
-        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
     }
     mapResponse(result) {
         const parent = this._join1.mappedServiceToDb;
         const parentTwo = this._join2.mappedServiceToDb;
         const parentThree = this._join3.mappedServiceToDb;
-        const response = responseMapper_1.default.map(this._table.mapServiceToDb(), result);
-        const objects = responseMapper_1.default.map(parent, result);
-        const objectsTwo = responseMapper_1.default.map(parentTwo, result);
-        const objectsThree = responseMapper_1.default.map(parentThree, result);
+        const response = this.fullOrPartial(this._table.mapServiceToDb(), result, this._partial);
+        const objects = this.fullOrPartial(parent, result, this._joinedPartial, 1);
+        const objectsTwo = this.fullOrPartial(parentTwo, result, this._joinedPartial1, 2);
+        const objectsThree = this.fullOrPartial(parentThree, result, this._joinedPartial2, 3);
         return new selectResponseThreeJoins_1.default(response, objects, objectsTwo, objectsThree);
     }
     joins() {
-        return [this._join1, this._join2, this._join3];
+        return [{ join: this._join1, partial: this._joinedPartial, id: 1 },
+            { join: this._join2, partial: this._joinedPartial1, id: 2 },
+            { join: this._join3, partial: this._joinedPartial2, id: 3 }];
     }
 }
 exports.default = SelectTRBWithThreeJoins;