drizzle-orm 0.10.21 → 0.10.24

package/dist/src/builders/highLvlBuilders/updateRequestBuilder.d.ts

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

package/dist/src/builders/highLvlBuilders/updateRequestBuilder.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const builderError_1 = __importStar(require("../../errors/builderError"));
+const responseMapper_1 = __importDefault(require("../../mappers/responseMapper"));
+const update_1 = __importDefault(require("../lowLvlBuilders/updates/update"));
+const static_1 = require("../requestBuilders/updates/static");
+const updates_1 = require("../requestBuilders/updates/updates");
+const abstractRequestBuilder_1 = __importDefault(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];
+                if (value instanceof updates_1.UpdateCustomExpr) {
+                    value.setColumn(column);
+                    updates.push(value);
+                }
+                else {
+                    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 = '';
+            let values = [];
+            try {
+                const builderResult = update_1.default.in(this._table)
+                    .columns()
+                    .set(this._update)
+                    .filteredBy(this._filter)
+                    .build();
+                query = builderResult.query;
+                values = builderResult.values;
+            }
+            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}`);
+                console.log(values);
+            }
+            const result = await this._session.execute(query, values);
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
+        };
+    }
+}
+exports.default = UpdateTRB;

package/dist/src/builders/index.d.ts

@@ -0,0 +1,18 @@
+export { default as DeleteTRB } from './highLvlBuilders/deleteRequestBuilder';
+export { default as InsertTRB } from './highLvlBuilders/insertRequestBuilder';
+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';
+export { default as Join } from './joinBuilders/join';
+export { default as SelectTRBWithJoin } from './joinBuilders/builders/selectWithJoin';
+export { default as SelectTRBWithTwoJoins } from './joinBuilders/builders/selectWithTwoJoins';
+export { default as SelectResponseTwoJoins } from './joinBuilders/responses/selectResponseTwoJoins';
+export { default as SelectResponseJoin } from './joinBuilders/responses/selectResponseWithJoin';
+export { default as Create } from './lowLvlBuilders/create';
+export { default as Delete } from './lowLvlBuilders/delets/delete';
+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, raw, isNotNull, } from './requestBuilders/where/static';

package/dist/src/builders/index.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotNull = 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 __importDefault(deleteRequestBuilder_1).default; } });
+var insertRequestBuilder_1 = require("./highLvlBuilders/insertRequestBuilder");
+Object.defineProperty(exports, "InsertTRB", { enumerable: true, get: function () { return __importDefault(insertRequestBuilder_1).default; } });
+var selectRequestBuilder_1 = require("./highLvlBuilders/selectRequestBuilder");
+Object.defineProperty(exports, "SelectTRB", { enumerable: true, get: function () { return __importDefault(selectRequestBuilder_1).default; } });
+var updateRequestBuilder_1 = require("./highLvlBuilders/updateRequestBuilder");
+Object.defineProperty(exports, "UpdateTRB", { enumerable: true, get: function () { return __importDefault(updateRequestBuilder_1).default; } });
+var static_1 = require("./joinBuilders/static");
+Object.defineProperty(exports, "to", { enumerable: true, get: function () { return __importDefault(static_1).default; } });
+var joinWith_1 = require("./joinBuilders/joinWith");
+Object.defineProperty(exports, "JoinWith", { enumerable: true, get: function () { return __importDefault(joinWith_1).default; } });
+var join_1 = require("./joinBuilders/join");
+Object.defineProperty(exports, "Join", { enumerable: true, get: function () { return __importDefault(join_1).default; } });
+var selectWithJoin_1 = require("./joinBuilders/builders/selectWithJoin");
+Object.defineProperty(exports, "SelectTRBWithJoin", { enumerable: true, get: function () { return __importDefault(selectWithJoin_1).default; } });
+var selectWithTwoJoins_1 = require("./joinBuilders/builders/selectWithTwoJoins");
+Object.defineProperty(exports, "SelectTRBWithTwoJoins", { enumerable: true, get: function () { return __importDefault(selectWithTwoJoins_1).default; } });
+var selectResponseTwoJoins_1 = require("./joinBuilders/responses/selectResponseTwoJoins");
+Object.defineProperty(exports, "SelectResponseTwoJoins", { enumerable: true, get: function () { return __importDefault(selectResponseTwoJoins_1).default; } });
+var selectResponseWithJoin_1 = require("./joinBuilders/responses/selectResponseWithJoin");
+Object.defineProperty(exports, "SelectResponseJoin", { enumerable: true, get: function () { return __importDefault(selectResponseWithJoin_1).default; } });
+var create_1 = require("./lowLvlBuilders/create");
+Object.defineProperty(exports, "Create", { enumerable: true, get: function () { return __importDefault(create_1).default; } });
+var delete_1 = require("./lowLvlBuilders/delets/delete");
+Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return __importDefault(delete_1).default; } });
+var insert_1 = require("./lowLvlBuilders/inserts/insert");
+Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return __importDefault(insert_1).default; } });
+var select_1 = require("./lowLvlBuilders/selects/select");
+Object.defineProperty(exports, "Select", { enumerable: true, get: function () { return __importDefault(select_1).default; } });
+var update_1 = require("./lowLvlBuilders/updates/update");
+Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return __importDefault(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; } });
+Object.defineProperty(exports, "isNotNull", { enumerable: true, get: function () { return static_3.isNotNull; } });

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

@@ -0,0 +1,40 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import { ISession } from '../../../db/session';
+import { AbstractTable } from '../../../tables';
+import { ExtractModel, FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+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, TPartial extends PartialFor<TTable> = {}> {
+    protected _table: TTable;
+    protected _session: ISession;
+    protected _filter: Expr;
+    protected _distinct?: AbstractColumn<ColumnType, boolean, boolean>;
+    protected _props: {
+        limit?: number;
+        offset?: number;
+    };
+    protected _orderBy?: AbstractColumn<ColumnType, boolean, boolean>;
+    protected _order?: Order;
+    protected _partial?: TPartial;
+    constructor(table: TTable, filter: Expr, session: ISession, props: {
+        limit?: number;
+        offset?: number;
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial);
+    limit: (limit: number) => this;
+    offset: (offset: number) => this;
+    execute: () => Promise<TRes>;
+    protected fullOrPartial<Table extends AbstractTable<Table>, Partial extends PartialFor<Table>>(mappedServiceToDb: {
+        [name in keyof ExtractModel<Table>]: AbstractColumn<ColumnType>;
+    }, result: QueryResult<any>, partial?: Partial, joinId?: number): Array<FullOrPartial<Table, Partial>>;
+    protected abstract mapResponse(result: QueryResult<any>): TRes;
+    protected abstract joins(): Array<{
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        };
+        id?: number;
+    }>;
+}

package/dist/src/builders/joinBuilders/builders/abstractJoinBuilder.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const builderError_1 = __importStar(require("../../../errors/builderError"));
+const responseMapper_1 = __importDefault(require("../../../mappers/responseMapper"));
+const select_1 = __importDefault(require("../../lowLvlBuilders/selects/select"));
+class AbstractJoined {
+    constructor(table, filter, session, props, orderBy, order, distinct, tablePartial) {
+        this.limit = (limit) => {
+            this._props.limit = limit;
+            return this;
+        };
+        this.offset = (offset) => {
+            this._props.offset = offset;
+            return this;
+        };
+        this.execute = async () => {
+            const queryBuilder = select_1.default
+                .from(this._table, this._partial)
+                .distinct(this._distinct)
+                .joined(this.joins())
+                .limit(this._props.limit)
+                .offset(this._props.offset)
+                .filteredBy(this._filter)
+                .orderBy(this._orderBy, this._order);
+            let query = '';
+            let values = [];
+            try {
+                const builderResult = queryBuilder.build();
+                query = builderResult.query;
+                values = builderResult.values;
+            }
+            catch (e) {
+                throw new builderError_1.default(builderError_1.BuilderType.JOINED_SELECT, this._table.tableName(), Object.values(this._table.mapServiceToDb()), e, this._filter);
+            }
+            console.log(query);
+            console.log(values);
+            const result = await this._session.execute(query, values);
+            return this.mapResponse(result);
+        };
+        this._table = table;
+        this._session = session;
+        this._filter = filter;
+        this._props = props;
+        this._order = order;
+        this._orderBy = orderBy;
+        this._distinct = distinct;
+        this._partial = tablePartial;
+    }
+    fullOrPartial(mappedServiceToDb, result, partial, joinId) {
+        if (partial) {
+            return responseMapper_1.default.partialMap(partial, result, joinId);
+        }
+        return responseMapper_1.default.map(mappedServiceToDb, result, joinId);
+    }
+}
+exports.default = AbstractJoined;

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

@@ -0,0 +1,35 @@
+import { QueryResult } from 'pg';
+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 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>, 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/dist/src/builders/joinBuilders/builders/selectWithFiveJoins.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const selectResponseFiveJoins_1 = __importDefault(require("../responses/selectResponseFiveJoins"));
+const abstractJoinBuilder_1 = __importDefault(require("./abstractJoinBuilder"));
+class SelectTRBWithFiveJoins extends abstractJoinBuilder_1.default {
+    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 [{ 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;
+        const parentTwo = this._join2.mappedServiceToDb;
+        const parentThree = this._join3.mappedServiceToDb;
+        const parentFour = this._join4.mappedServiceToDb;
+        const parentFive = this._join5.mappedServiceToDb;
+        // 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);
+    }
+}
+exports.default = SelectTRBWithFiveJoins;

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

@@ -0,0 +1,55 @@
+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';
+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 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>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3, joinedPartial3?: TPartial4);
+    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: CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>) => AbstractColumn<TColumn, boolean, boolean, CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>>, to: (table: IToTable) => AbstractColumn<TToColumn, 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, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>) => AbstractColumn<TColumn, boolean, boolean, CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>>, to: (table: IToTable) => AbstractColumn<TToColumn, 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, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>) => AbstractColumn<TColumn, boolean, boolean, CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>>, to: (table: IToTable) => AbstractColumn<TToColumn, 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, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, table: {
+        new (db: DB): IToTable;
+    }, from: (table: CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>) => AbstractColumn<TColumn, boolean, boolean, CheckFiveTypes<InputTable, TTable, TTable1, TTable2, TTable3, TTable4>>, to: (table: IToTable) => AbstractColumn<TToColumn>, 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/dist/src/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/src/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/src/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;