drizzle-orm 0.9.0 → 0.9.4

package/builders/highLvlBuilders/selectRequestBuilder.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable import/no-cycle */
+const __1 = require("..");
+const builderError_1 = require("../../errors/builderError");
+const dbErrors_1 = require("../../errors/dbErrors");
+const responseMapper_1 = require("../../mappers/responseMapper");
+const selectWithJoin_1 = require("../joinBuilders/builders/selectWithJoin");
+const join_1 = require("../joinBuilders/join");
+const abstractRequestBuilder_1 = require("./abstractRequestBuilder");
+class SelectTRB extends abstractRequestBuilder_1.default {
+    constructor(session, mappedServiceToDb, props, table, logger) {
+        super(table, session, mappedServiceToDb, logger);
+        this.where = (expr) => {
+            this._filter = expr;
+            return this;
+        };
+        this.distinct = (column) => {
+            this.__distinct = column;
+            return this;
+        };
+        this.execute = async () => {
+            const res = await this._execute();
+            return res;
+        };
+        this._execute = async () => {
+            // Select.from().filteredBy().limit().offset().orderBy().groupBy().build()
+            const queryBuilder = __1.Select
+                .from(this._table)
+                .distinct(this.__distinct)
+                .filteredBy(this._filter)
+                .limit(this.props.limit)
+                .offset(this.props.offset)
+                .orderBy(this.__orderBy, this.__order);
+            let query = '';
+            try {
+                query = queryBuilder.build();
+            }
+            catch (e) {
+                throw new builderError_1.default(builderError_1.BuilderType.SELECT, this._table.tableName(), this._columns, e, this._filter);
+            }
+            if (this._logger) {
+                this._logger.info(`Selecting from ${this._table.tableName()} using query:\n ${query}`);
+            }
+            const result = await this._session.execute(query);
+            if (result.isLeft()) {
+                const { reason } = result.value;
+                throw new dbErrors_1.DatabaseSelectError(this._table.tableName(), reason, query);
+            }
+            else {
+                return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
+            }
+        };
+        this.props = props;
+    }
+    orderBy(callback, order) {
+        this.__orderBy = callback(this._table);
+        this.__order = order;
+        return this;
+    }
+    // public groupBy(callback: (table: TTable) => Column<ColumnType, boolean, boolean>)
+    //   : SelectTRB<TTable> {
+    //   this.__groupBy = callback(this.__table);
+    //   return this;
+    // }
+    innerJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        const toColumn = to(toTable);
+        const join = new __1.JoinWith(toTable.tableName(), toTable.mapServiceToDb())
+            .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.INNER_JOIN);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct);
+    }
+    leftJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        const toColumn = to(toTable);
+        const join = new __1.JoinWith(toTable.tableName(), toTable.mapServiceToDb())
+            .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.LEFT_JOIN);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct);
+    }
+    rightJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        const toColumn = to(toTable);
+        const join = new __1.JoinWith(toTable.tableName(), toTable.mapServiceToDb())
+            .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.RIGHT_JOIN);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct);
+    }
+    fullJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        const toColumn = to(toTable);
+        const join = new __1.JoinWith(toTable.tableName(), toTable.mapServiceToDb())
+            .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.FULL_JOIN);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct);
+    }
+}
+exports.default = SelectTRB;

package/builders/highLvlBuilders/updateRequestBuilder.d.ts

@@ -0,0 +1,20 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import Session from '../../db/session';
+import BaseLogger from '../../logger/abstractLogger';
+import { AbstractTable } from '../../tables';
+import { ExtractModel } from '../../tables/inferTypes';
+import Expr from '../requestBuilders/where/where';
+import TableRequestBuilder from './abstractRequestBuilder';
+export default class UpdateTRB<TTable extends AbstractTable<TTable>> extends TableRequestBuilder<TTable> {
+    private _filter;
+    private _update;
+    private _objToUpdate;
+    constructor(table: AbstractTable<TTable>, session: Session, mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
+    }, logger?: BaseLogger);
+    where: (expr: Expr) => UpdateTRB<TTable>;
+    set: (expr: Partial<ExtractModel<TTable>>) => UpdateTRB<TTable>;
+    execute: () => Promise<void>;
+    protected _execute: () => Promise<Array<ExtractModel<TTable> | undefined>>;
+}

package/builders/highLvlBuilders/updateRequestBuilder.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const builderError_1 = require("../../errors/builderError");
+const dbErrors_1 = require("../../errors/dbErrors");
+const responseMapper_1 = require("../../mappers/responseMapper");
+const update_1 = require("../lowLvlBuilders/updates/update");
+const static_1 = require("../requestBuilders/updates/static");
+const abstractRequestBuilder_1 = require("./abstractRequestBuilder");
+class UpdateTRB extends abstractRequestBuilder_1.default {
+    constructor(table, session, mappedServiceToDb, logger) {
+        super(table, session, mappedServiceToDb, logger);
+        this.where = (expr) => {
+            this._filter = expr;
+            return this;
+        };
+        this.set = (expr) => {
+            const updates = [];
+            Object.entries(expr).forEach(([key, value]) => {
+                const column = this._mappedServiceToDb[key];
+                updates.push(static_1.set(column, value));
+            });
+            this._update = static_1.combine(updates);
+            return this;
+        };
+        this.execute = async () => {
+            await this._execute();
+        };
+        this._execute = async () => {
+            let query = '';
+            try {
+                query = update_1.default.in(this._table)
+                    .columns()
+                    .set(this._update)
+                    .filteredBy(this._filter)
+                    .build();
+            }
+            catch (e) {
+                throw new builderError_1.default(builderError_1.BuilderType.UPDATE, this._table.tableName(), this._columns, e, this._filter);
+            }
+            if (this._logger) {
+                this._logger.info(`Updating ${this._table.tableName()} using query:\n ${query}`);
+            }
+            const result = await this._session.execute(query);
+            if (result.isLeft()) {
+                const { reason } = result.value;
+                throw new dbErrors_1.DatabaseUpdateError(this._table.tableName(), reason, query);
+            }
+            else {
+                return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
+            }
+        };
+    }
+}
+exports.default = UpdateTRB;

package/{src/builders/index.ts → builders/index.d.ts}

@@ -1,6 +1,6 @@
 export { default as DeleteTRB } from './highLvlBuilders/deleteRequestBuilder';
 export { default as InsertTRB } from './highLvlBuilders/insertRequestBuilder';
-export { default as SelectTRBs } from './highLvlBuilders/selectRequestBuilder';
+export { default as SelectTRB } from './highLvlBuilders/selectRequestBuilder';
 export { default as UpdateTRB } from './highLvlBuilders/updateRequestBuilder';
 export { default as to } from './joinBuilders/static';
 export { default as JoinWith } from './joinBuilders/joinWith';
@@ -15,6 +15,4 @@ export { default as Insert } from './lowLvlBuilders/inserts/insert';
 export { default as Select } from './lowLvlBuilders/selects/select';
 export { default as Update } from './lowLvlBuilders/updates/update';
 export { set, combine } from './requestBuilders/updates/static';
-export {
-  eq, inArray as in, and, or, like, greater, greaterEq, less, lessEq,
-} from './requestBuilders/where/static';
+export { eq, inArray as in, and, or, like, greater, greaterEq, less, lessEq, raw, } from './requestBuilders/where/static';

package/builders/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.raw = exports.lessEq = exports.less = exports.greaterEq = exports.greater = exports.like = exports.or = exports.and = exports.in = exports.eq = exports.combine = exports.set = exports.Update = exports.Select = exports.Insert = exports.Delete = exports.Create = exports.SelectResponseJoin = exports.SelectResponseTwoJoins = exports.SelectTRBWithTwoJoins = exports.SelectTRBWithJoin = exports.Join = exports.JoinWith = exports.to = exports.UpdateTRB = exports.SelectTRB = exports.InsertTRB = exports.DeleteTRB = void 0;
+/* eslint-disable import/no-cycle */
+var deleteRequestBuilder_1 = require("./highLvlBuilders/deleteRequestBuilder");
+Object.defineProperty(exports, "DeleteTRB", { enumerable: true, get: function () { return deleteRequestBuilder_1.default; } });
+var insertRequestBuilder_1 = require("./highLvlBuilders/insertRequestBuilder");
+Object.defineProperty(exports, "InsertTRB", { enumerable: true, get: function () { return insertRequestBuilder_1.default; } });
+var selectRequestBuilder_1 = require("./highLvlBuilders/selectRequestBuilder");
+Object.defineProperty(exports, "SelectTRB", { enumerable: true, get: function () { return selectRequestBuilder_1.default; } });
+var updateRequestBuilder_1 = require("./highLvlBuilders/updateRequestBuilder");
+Object.defineProperty(exports, "UpdateTRB", { enumerable: true, get: function () { return updateRequestBuilder_1.default; } });
+var static_1 = require("./joinBuilders/static");
+Object.defineProperty(exports, "to", { enumerable: true, get: function () { return static_1.default; } });
+var joinWith_1 = require("./joinBuilders/joinWith");
+Object.defineProperty(exports, "JoinWith", { enumerable: true, get: function () { return joinWith_1.default; } });
+var join_1 = require("./joinBuilders/join");
+Object.defineProperty(exports, "Join", { enumerable: true, get: function () { return join_1.default; } });
+var selectWithJoin_1 = require("./joinBuilders/builders/selectWithJoin");
+Object.defineProperty(exports, "SelectTRBWithJoin", { enumerable: true, get: function () { return selectWithJoin_1.default; } });
+var selectWithTwoJoins_1 = require("./joinBuilders/builders/selectWithTwoJoins");
+Object.defineProperty(exports, "SelectTRBWithTwoJoins", { enumerable: true, get: function () { return selectWithTwoJoins_1.default; } });
+var selectResponseTwoJoins_1 = require("./joinBuilders/responses/selectResponseTwoJoins");
+Object.defineProperty(exports, "SelectResponseTwoJoins", { enumerable: true, get: function () { return selectResponseTwoJoins_1.default; } });
+var selectResponseWithJoin_1 = require("./joinBuilders/responses/selectResponseWithJoin");
+Object.defineProperty(exports, "SelectResponseJoin", { enumerable: true, get: function () { return selectResponseWithJoin_1.default; } });
+var create_1 = require("./lowLvlBuilders/create");
+Object.defineProperty(exports, "Create", { enumerable: true, get: function () { return create_1.default; } });
+var delete_1 = require("./lowLvlBuilders/delets/delete");
+Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return delete_1.default; } });
+var insert_1 = require("./lowLvlBuilders/inserts/insert");
+Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return insert_1.default; } });
+var select_1 = require("./lowLvlBuilders/selects/select");
+Object.defineProperty(exports, "Select", { enumerable: true, get: function () { return select_1.default; } });
+var update_1 = require("./lowLvlBuilders/updates/update");
+Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return update_1.default; } });
+var static_2 = require("./requestBuilders/updates/static");
+Object.defineProperty(exports, "set", { enumerable: true, get: function () { return static_2.set; } });
+Object.defineProperty(exports, "combine", { enumerable: true, get: function () { return static_2.combine; } });
+var static_3 = require("./requestBuilders/where/static");
+Object.defineProperty(exports, "eq", { enumerable: true, get: function () { return static_3.eq; } });
+Object.defineProperty(exports, "in", { enumerable: true, get: function () { return static_3.inArray; } });
+Object.defineProperty(exports, "and", { enumerable: true, get: function () { return static_3.and; } });
+Object.defineProperty(exports, "or", { enumerable: true, get: function () { return static_3.or; } });
+Object.defineProperty(exports, "like", { enumerable: true, get: function () { return static_3.like; } });
+Object.defineProperty(exports, "greater", { enumerable: true, get: function () { return static_3.greater; } });
+Object.defineProperty(exports, "greaterEq", { enumerable: true, get: function () { return static_3.greaterEq; } });
+Object.defineProperty(exports, "less", { enumerable: true, get: function () { return static_3.less; } });
+Object.defineProperty(exports, "lessEq", { enumerable: true, get: function () { return static_3.lessEq; } });
+Object.defineProperty(exports, "raw", { enumerable: true, get: function () { return static_3.raw; } });

package/builders/joinBuilders/builders/abstractJoinBuilder.d.ts

@@ -0,0 +1,27 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import Session from '../../../db/session';
+import { AbstractTable } from '../../../tables';
+import Order from '../../highLvlBuilders/order';
+import Expr from '../../requestBuilders/where/where';
+import Join from '../join';
+export default abstract class AbstractJoined<TTable extends AbstractTable<TTable>, TRes> {
+    protected _table: TTable;
+    protected _session: Session;
+    protected _filter: Expr;
+    protected _distinct?: AbstractColumn<ColumnType, boolean, boolean>;
+    protected _props: {
+        limit?: number;
+        offset?: number;
+    };
+    protected _orderBy?: AbstractColumn<ColumnType, boolean, boolean>;
+    protected _order?: Order;
+    constructor(table: TTable, filter: Expr, session: Session, props: {
+        limit?: number;
+        offset?: number;
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);
+    execute: () => Promise<TRes>;
+    protected abstract mapResponse(result: QueryResult<any>): TRes;
+    protected abstract joins(): Array<Join<any>>;
+}

package/builders/joinBuilders/builders/abstractJoinBuilder.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const builderError_1 = require("../../../errors/builderError");
+const dbErrors_1 = require("../../../errors/dbErrors");
+const select_1 = require("../../lowLvlBuilders/selects/select");
+class AbstractJoined {
+    constructor(table, filter, session, props, orderBy, order, distinct) {
+        this.execute = async () => {
+            const queryBuilder = select_1.default
+                .from(this._table)
+                .distinct(this._distinct)
+                .joined(this.joins())
+                .limit(this._props.limit)
+                .offset(this._props.offset)
+                .filteredBy(this._filter)
+                .orderBy(this._orderBy, this._order);
+            let query = '';
+            try {
+                query = queryBuilder.build();
+            }
+            catch (e) {
+                throw new builderError_1.default(builderError_1.BuilderType.JOINED_SELECT, this._table.tableName(), Object.values(this._table.mapServiceToDb()), e, this._filter);
+            }
+            const result = await this._session.execute(query);
+            if (result.isLeft()) {
+                const { reason } = result.value;
+                throw new dbErrors_1.DatabaseSelectError(this._table.tableName(), reason, query);
+            }
+            else {
+                return this.mapResponse(result.value);
+            }
+        };
+        this._table = table;
+        this._session = session;
+        this._filter = filter;
+        this._props = props;
+        this._order = order;
+        this._orderBy = orderBy;
+        this._distinct = distinct;
+    }
+}
+exports.default = AbstractJoined;

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

@@ -0,0 +1,23 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import Session from '../../../db/session';
+import { AbstractTable } from '../../../tables';
+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>> {
+    private _join1;
+    private _join2;
+    private _join3;
+    private _join4;
+    private _join5;
+    constructor(table: TTable, session: Session, 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>;
+}

package/builders/joinBuilders/builders/selectWithFiveJoins.js

@@ -0,0 +1,33 @@
+"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);
+        this._join1 = join1;
+        this._join2 = join2;
+        this._join3 = join3;
+        this._join4 = join4;
+        this._join5 = join5;
+    }
+    joins() {
+        return [this._join1, this._join2, this._join3, this._join4, this._join5];
+    }
+    mapResponse(result) {
+        const parent = this._join1.mappedServiceToDb;
+        const parentTwo = this._join2.mappedServiceToDb;
+        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);
+        return new selectResponseFiveJoins_1.default(response, objects, objectsTwo, objectsThree, objectsFour, objectsFive);
+    }
+}
+exports.default = SelectTRBWithFiveJoins;

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

@@ -0,0 +1,36 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import DB from '../../../db/db';
+import Session from '../../../db/session';
+import { AbstractTable } from '../../../tables';
+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>> {
+    private _join1;
+    private _join2;
+    private _join3;
+    private _join4;
+    constructor(table: TTable, session: Session, 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: {
+        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: {
+        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: {
+        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: {
+        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>;
+}

package/builders/joinBuilders/builders/selectWithFourJoins.js

@@ -0,0 +1,65 @@
+"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);
+        this._join1 = join1;
+        this._join2 = join2;
+        this._join3 = join3;
+        this._join4 = join4;
+    }
+    innerJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        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);
+    }
+    leftJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        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);
+    }
+    rightJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        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);
+    }
+    fullJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        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);
+    }
+    joins() {
+        return [this._join1, this._join2, this._join3, this._join4];
+    }
+    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);
+        return new selectResponseFourJoins_1.default(response, objects, objectsTwo, objectsThree, objectsFour);
+    }
+}
+exports.default = SelectTRBWithFourJoins;

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

@@ -0,0 +1,33 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import DB from '../../../db/db';
+import Session from '../../../db/session';
+import AbstractTable from '../../../tables/abstractTable';
+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>> {
+    private _join;
+    constructor(table: TTable, session: Session, 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: {
+        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: {
+        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: {
+        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: {
+        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>;
+}

package/builders/joinBuilders/builders/selectWithJoin.js

@@ -0,0 +1,56 @@
+"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");
+class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
+    constructor(table, session, filter, join, props, orderBy, order, distinct) {
+        super(table, filter, session, props, orderBy, order, distinct);
+        this._join = join;
+    }
+    innerJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        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);
+    }
+    leftJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        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);
+    }
+    rightJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        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);
+    }
+    fullJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        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);
+    }
+    joins() {
+        return [this._join];
+    }
+    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);
+        return new selectResponseWithJoin_1.default(response, objects);
+    }
+}
+exports.default = SelectTRBWithJoin;

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

@@ -0,0 +1,35 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import DB from '../../../db/db';
+import Session from '../../../db/session';
+import AbstractTable from '../../../tables/abstractTable';
+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>> {
+    private _join1;
+    private _join2;
+    private _join3;
+    constructor(table: TTable, session: Session, 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: {
+        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: {
+        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: {
+        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: {
+        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>[];
+}