drizzle-orm 0.10.26 → 0.10.27

package/dist/builders/joinBuilders/builders/selectWithFourJoins.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const join_1 = require("../join");
+const joinWith_1 = __importDefault(require("../joinWith"));
+const selectResponseFourJoins_1 = __importDefault(require("../responses/selectResponseFourJoins"));
+const abstractJoinBuilder_1 = __importDefault(require("./abstractJoinBuilder"));
+const selectWithFiveJoins_1 = __importDefault(require("./selectWithFiveJoins"));
+class SelectTRBWithFourJoins extends abstractJoinBuilder_1.default {
+    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(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
+    }
+    leftJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
+    }
+    rightJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
+    }
+    fullJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
+    }
+    joins() {
+        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 = 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);
+    }
+}
+exports.default = SelectTRBWithFourJoins;

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

@@ -0,0 +1,49 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+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 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>, tablePartial?: TPartial, joinedPartial?: TPartial1);
+    innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckTwoTypes<InputTable, TTable, TTable1>) => AbstractColumn<TColumn, boolean, boolean, CheckTwoTypes<InputTable, TTable, TTable1>>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithTwoJoins<TTable, TTable1, IToTable, TPartial, TPartial1, IToPartial>;
+    leftJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckTwoTypes<InputTable, TTable, TTable1>) => AbstractColumn<TColumn, boolean, boolean, CheckTwoTypes<InputTable, TTable, TTable1>>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithTwoJoins<TTable, TTable1, IToTable, TPartial, TPartial1, IToPartial>;
+    rightJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckTwoTypes<InputTable, TTable, TTable1>) => AbstractColumn<TColumn, boolean, boolean, CheckTwoTypes<InputTable, TTable, TTable1>>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithTwoJoins<TTable, TTable1, IToTable, TPartial, TPartial1, IToPartial>;
+    fullJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckTwoTypes<InputTable, TTable, TTable1>) => AbstractColumn<TColumn, boolean, boolean, CheckTwoTypes<InputTable, TTable, TTable1>>, to: (table: IToTable) => AbstractColumn<TToColumn, 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/dist/builders/joinBuilders/builders/selectWithJoin.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const join_1 = require("../join");
+const joinWith_1 = __importDefault(require("../joinWith"));
+const selectResponseWithJoin_1 = __importDefault(require("../responses/selectResponseWithJoin"));
+const abstractJoinBuilder_1 = __importDefault(require("./abstractJoinBuilder"));
+const selectWithTwoJoins_1 = __importDefault(require("./selectWithTwoJoins"));
+// eslint-disable-next-line max-len
+class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
+    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(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, partial);
+    }
+    leftJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, partial);
+    }
+    rightJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, partial);
+    }
+    fullJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, partial);
+    }
+    joins() {
+        return [{ join: this._join, partial: this._joinedPartial, id: 1 }];
+    }
+    mapResponse(result) {
+        const parent = this._join.mappedServiceToDb;
+        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);
+    }
+}
+exports.default = SelectTRBWithJoin;

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

@@ -0,0 +1,53 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+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 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>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3);
+    innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>) => AbstractColumn<TColumn, boolean, boolean, CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable, TPartial, TPartial1, TPartial2, TPartial3, IToPartial>;
+    leftJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>) => AbstractColumn<TColumn, boolean, boolean, CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable, TPartial, TPartial1, TPartial2, TPartial3, IToPartial>;
+    rightJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>) => AbstractColumn<TColumn, boolean, boolean, CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable, TPartial, TPartial1, TPartial2, TPartial3, IToPartial>;
+    fullJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>) => AbstractColumn<TColumn, boolean, boolean, CheckFourTypes<InputTable, TTable, TTable1, TTable2, TTable3>>, to: (table: IToTable) => AbstractColumn<TToColumn, 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/dist/builders/joinBuilders/builders/selectWithThreeJoins.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const join_1 = require("../join");
+const joinWith_1 = __importDefault(require("../joinWith"));
+const selectResponseThreeJoins_1 = __importDefault(require("../responses/selectResponseThreeJoins"));
+const abstractJoinBuilder_1 = __importDefault(require("./abstractJoinBuilder"));
+const selectWithFourJoins_1 = __importDefault(require("./selectWithFourJoins"));
+class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
+    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(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
+    }
+    leftJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
+    }
+    rightJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
+    }
+    fullJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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, 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 = 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 [{ 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;

package/dist/builders/joinBuilders/builders/selectWithTwoJoins.d.ts

@@ -0,0 +1,51 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import DB from '../../../db/db';
+import { ISession } from '../../../db/session';
+import AbstractTable from '../../../tables/abstractTable';
+import { CheckThreeTypes, PartialFor } from '../../../tables/inferTypes';
+import Order from '../../highLvlBuilders/order';
+import Expr from '../../requestBuilders/where/where';
+import Join from '../join';
+import SelectResponseTwoJoins from '../responses/selectResponseTwoJoins';
+import AbstractJoined from './abstractJoinBuilder';
+import SelectTRBWithThreeJoins from './selectWithThreeJoins';
+export default class SelectTRBWithTwoJoins<TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>, TPartial extends PartialFor<TTable> = {}, TPartial1 extends PartialFor<TTable1> = {}, TPartial2 extends PartialFor<TTable2> = {}> extends AbstractJoined<TTable, SelectResponseTwoJoins<TTable, TTable1, TTable2, TPartial, TPartial1, TPartial2>, TPartial> {
+    private _join1;
+    private _join2;
+    private _joinedPartial?;
+    private _joinedPartial1?;
+    constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, props: {
+        limit?: number;
+        offset?: number;
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2);
+    innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial>;
+    leftJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial>;
+    rightJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial>;
+    fullJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial>;
+    protected mapResponse(result: QueryResult<any>): SelectResponseTwoJoins<TTable, TTable1, TTable2, TPartial, TPartial1, TPartial2>;
+    protected joins(): Array<{
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        };
+        id?: number;
+    }>;
+}

package/dist/builders/joinBuilders/builders/selectWithTwoJoins.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const join_1 = require("../join");
+const joinWith_1 = __importDefault(require("../joinWith"));
+const selectResponseTwoJoins_1 = __importDefault(require("../responses/selectResponseTwoJoins"));
+const abstractJoinBuilder_1 = __importDefault(require("./abstractJoinBuilder"));
+const selectWithThreeJoins_1 = __importDefault(require("./selectWithThreeJoins"));
+class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
+    constructor(table, session, filter, join1, join2, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
+        this._join1 = join1;
+        this._join2 = join2;
+        this._joinedPartial = joinedPartial;
+        this._joinedPartial1 = joinedPartial1;
+    }
+    innerJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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 selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
+    }
+    leftJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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 selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
+    }
+    rightJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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 selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
+    }
+    fullJoin(fromTable, table, from, to, partial) {
+        const toTable = this._table.db.create(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 selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
+    }
+    mapResponse(result) {
+        const parent = this._join1.mappedServiceToDb;
+        const parentTwo = this._join2.mappedServiceToDb;
+        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);
+        return new selectResponseTwoJoins_1.default(response, objects, objectsTwo);
+    }
+    joins() {
+        return [{ join: this._join1, partial: this._joinedPartial, id: 1 },
+            { join: this._join2, partial: this._joinedPartial1, id: 2 }];
+    }
+}
+exports.default = SelectTRBWithTwoJoins;

package/dist/builders/joinBuilders/join.d.ts

@@ -0,0 +1,23 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { ExtractModel } from '../../tables/inferTypes';
+export default class Join<TTable> {
+    fromColumn: AbstractColumn<ColumnType, boolean, boolean>;
+    toColumn: AbstractColumn<ColumnType, boolean, boolean>;
+    joinTableName: string;
+    mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
+    };
+    type: JoinStrategy;
+    constructor(joinTableName: string, fromColumn: AbstractColumn<ColumnType, boolean, boolean>, toColumn: AbstractColumn<ColumnType, boolean, boolean>, mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
+    });
+    joinStrategy: (type: JoinStrategy) => Join<TTable>;
+    columns: (fromColumn: AbstractColumn<ColumnType>, toColumn: AbstractColumn<ColumnType>) => Join<TTable>;
+}
+export declare enum JoinStrategy {
+    INNER_JOIN = "INNER JOIN",
+    LEFT_JOIN = "LEFT JOIN",
+    RIGHT_JOIN = "RIGHT JOIN",
+    FULL_JOIN = "FULL JOIN"
+}

package/dist/builders/joinBuilders/join.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinStrategy = void 0;
+class Join {
+    constructor(joinTableName, fromColumn, toColumn, mappedServiceToDb) {
+        this.joinStrategy = (type) => {
+            this.type = type;
+            return this;
+        };
+        this.columns = (fromColumn, toColumn) => {
+            this.toColumn = toColumn;
+            this.fromColumn = fromColumn;
+            return this;
+        };
+        this.joinTableName = joinTableName;
+        this.toColumn = toColumn;
+        this.fromColumn = fromColumn;
+        this.mappedServiceToDb = mappedServiceToDb;
+    }
+}
+exports.default = Join;
+var JoinStrategy;
+(function (JoinStrategy) {
+    JoinStrategy["INNER_JOIN"] = "INNER JOIN";
+    JoinStrategy["LEFT_JOIN"] = "LEFT JOIN";
+    JoinStrategy["RIGHT_JOIN"] = "RIGHT JOIN";
+    JoinStrategy["FULL_JOIN"] = "FULL JOIN";
+})(JoinStrategy = exports.JoinStrategy || (exports.JoinStrategy = {}));

package/dist/builders/joinBuilders/joinWith.d.ts

@@ -0,0 +1,14 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { ExtractModel } from '../../tables/inferTypes';
+import Join from './join';
+export default class JoinWith<TColumn extends ColumnType, TTable> {
+    joinTableName: string;
+    mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<TColumn>;
+    };
+    constructor(joinTableName: string, mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<TColumn>;
+    });
+    columns: (fromColumn: AbstractColumn<TColumn, boolean, boolean>, toColumn: AbstractColumn<TColumn, boolean, boolean>) => Join<TTable>;
+}

package/dist/builders/joinBuilders/joinWith.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const join_1 = __importDefault(require("./join"));
+class JoinWith {
+    constructor(joinTableName, mappedServiceToDb) {
+        this.columns = (fromColumn, toColumn) => new join_1.default(this.joinTableName, fromColumn, toColumn, this.mappedServiceToDb);
+        this.joinTableName = joinTableName;
+        this.mappedServiceToDb = mappedServiceToDb;
+    }
+}
+exports.default = JoinWith;

package/dist/builders/joinBuilders/responses/selectResponseFiveJoins.d.ts

@@ -0,0 +1,20 @@
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+export default class SelectResponseFiveJoins<T1 extends AbstractTable<T1>, T2 extends AbstractTable<T2>, T3 extends AbstractTable<T3>, T4 extends AbstractTable<T4>, T5 extends AbstractTable<T5>, T6 extends AbstractTable<T6>, TPartial1 extends PartialFor<T1>, TPartial2 extends PartialFor<T2>, TPartial3 extends PartialFor<T3>, TPartial4 extends PartialFor<T4>, TPartial5 extends PartialFor<T5>, TPartial6 extends PartialFor<T6>> {
+    _t1: Array<FullOrPartial<T1, TPartial1>>;
+    _t2: Array<FullOrPartial<T2, TPartial2>>;
+    _t3: Array<FullOrPartial<T3, TPartial3>>;
+    _t4: Array<FullOrPartial<T4, TPartial4>>;
+    _t5: Array<FullOrPartial<T5, TPartial5>>;
+    _t6: Array<FullOrPartial<T6, TPartial6>>;
+    constructor(t1: Array<FullOrPartial<T1, TPartial1>>, t2: Array<FullOrPartial<T2, TPartial2>>, t3: Array<FullOrPartial<T3, TPartial3>>, t4: Array<FullOrPartial<T4, TPartial4>>, t5: Array<FullOrPartial<T5, TPartial5>>, t6: Array<FullOrPartial<T6, TPartial6>>);
+    map: <M>(imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>, t6: FullOrPartial<T6, TPartial6>) => M) => M[];
+    foreach: (imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>, t6: FullOrPartial<T6, TPartial6>) => void) => void;
+    group: <TOne, TMany>({ one, many, }: {
+        one: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>, t6: FullOrPartial<T6, TPartial6>) => TOne;
+        many: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>, t6: FullOrPartial<T6, TPartial6>) => TMany;
+    }) => {
+        one: TOne;
+        many: TMany[];
+    };
+}

package/dist/builders/joinBuilders/responses/selectResponseFiveJoins.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SelectResponseFiveJoins {
+    constructor(t1, t2, t3, t4, t5, t6) {
+        this.map = (imac) => {
+            const objects = new Array();
+            for (let i = 0; i < this._t1.length; i += 1) {
+                objects.push(imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i], this._t6[i]));
+            }
+            return objects;
+        };
+        this.foreach = (imac) => {
+            for (let i = 0; i < this._t1.length; i += 1) {
+                imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i], this._t6[i]);
+            }
+        };
+        this.group = ({ one, many, }) => {
+            const objects = new Array();
+            for (let i = 0; i < this._t1.length; i += 1) {
+                objects.push(many(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i], this._t6[i]));
+            }
+            return {
+                one: one(this._t1[0], this._t2[0], this._t3[0], this._t4[0], this._t5[0], this._t6[0]),
+                many: objects,
+            };
+        };
+        this._t1 = t1;
+        this._t2 = t2;
+        this._t3 = t3;
+        this._t4 = t4;
+        this._t5 = t5;
+        this._t6 = t6;
+    }
+}
+exports.default = SelectResponseFiveJoins;

package/dist/builders/joinBuilders/responses/selectResponseFourJoins.d.ts

@@ -0,0 +1,19 @@
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+export default class SelectResponseFourJoins<T1 extends AbstractTable<T1>, T2 extends AbstractTable<T2>, T3 extends AbstractTable<T3>, T4 extends AbstractTable<T4>, T5 extends AbstractTable<T5>, TPartial1 extends PartialFor<T1>, TPartial2 extends PartialFor<T2>, TPartial3 extends PartialFor<T3>, TPartial4 extends PartialFor<T4>, TPartial5 extends PartialFor<T5>> {
+    _t1: Array<FullOrPartial<T1, TPartial1>>;
+    _t2: Array<FullOrPartial<T2, TPartial2>>;
+    _t3: Array<FullOrPartial<T3, TPartial3>>;
+    _t4: Array<FullOrPartial<T4, TPartial4>>;
+    _t5: Array<FullOrPartial<T5, TPartial5>>;
+    constructor(t1: Array<FullOrPartial<T1, TPartial1>>, t2: Array<FullOrPartial<T2, TPartial2>>, t3: Array<FullOrPartial<T3, TPartial3>>, t4: Array<FullOrPartial<T4, TPartial4>>, t5: Array<FullOrPartial<T5, TPartial5>>);
+    map: <M>(imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>) => M) => M[];
+    foreach: (imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>) => void) => void;
+    group: <TOne, TMany>({ one, many, }: {
+        one: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>) => TOne;
+        many: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>) => TMany;
+    }) => {
+        one: TOne;
+        many: TMany[];
+    };
+}