drizzle-orm 0.10.45 → 0.11.0

package/README.md

@@ -342,79 +342,71 @@ await usersTable.insertMany([{
 const usersTable = new UsersTable(db);
 const citiesTable = new CitiesTable(db);
 
- const userWithCities = await citiesTable.select()
-      .where(eq(citiesTable.id, 1))
-      .leftJoin(UsersTable,
-        (city) => city.userId,
-        (users) => users.id)
-      .execute();
+const userWithCities = await citiesTable.select()
+  .where(eq(citiesTable.id, 1))
+  .leftJoin(usersTable, (cities, users) => onEq(cities.userId, users.id))
+  .execute();
 
 const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
 ```
 
 ### Join Many-To-Many Tables
-##### Join User Groups with Users, using many-to-many table and map response to get user object with groups array
-```typescript
-    const usersWithUserGroups = await usersToUserGroupsTable.select()
-      .where(eq(userGroupsTable.id, 1))
-      .leftJoin(UsersTable,
-        (userToGroup) => userToGroup.userId,
-        (users) => users.id)
-      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,
-        (userToGroup) => userToGroup.groupId,
-        (users) => users.id)
-      .execute();
-
-    const userGroupWithUsers = usersWithUserGroups.group({
-      one: (_, dbUser, dbUserGroup) => dbUser!,
-      many: (_, dbUser, dbUserGroup) => dbUserGroup!,
-    });
-
-    const userWithGroups: ExtractModel<UsersTable> & { groups: ExtractModel<UserGroupsTable>[] } = {
-      ...userGroupWithUsers.one,
-      groups: userGroupWithUsers.many,
-    };
-```
-##### Join User Groups with Users, using many-to-many table and map response to get user group object with users array
+##### Join User Groups with Users, using many-to-many table
 ```typescript
-    const usersWithUserGroups = await usersToUserGroupsTable.select()
+  const usersWithUserGroups = await usersToUserGroupsTable.select()
       .where(eq(userGroupsTable.id, 1))
-      .leftJoin(UsersTable,
-        (userToGroup) => userToGroup.userId,
-        (users) => users.id)
-      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,
-        (userToGroup) => userToGroup.groupId,
-        (users) => users.id)
+      .leftJoin(usersTable, (usersToUserGroups, users) => onEq(usersToUserGroups.userId, users.id))
+      .leftJoin(userGroupsTable, (usersToUserGroups, _users, userGroups) => onEq(usersToUserGroups.groupId, userGroups.id))
       .execute();
-
-    const userGroupWithUsers = usersWithUserGroups.group({
-      one: (_, dbUser, dbUserGroup) => dbUserGroup!,
-      many: (_, dbUser, dbUserGroup) => dbUser!,
-    });
-
-    const userWithGroups: ExtractModel<UserGroupsTable> & { users: ExtractModel<UsersTable>[] } = {
-      ...userGroupWithUsers.one,
-      users: userGroupWithUsers.many,
-    };
 ```
 ### Join using partial field select
 ##### Join Cities with Users getting only needed fields form request
 ```typescript
-await citiesTable.select({
+    await citiesTable.select({
       id: citiesTable.id,
       userId: citiesTable.userId,
     })
-    .where(eq(citiesTable.id, 1))
-    .leftJoin(UsersTable,
-        (city) => city.userId,
-        (users) => users.id,
-        {
-          id: usersTable.id,
-        })
-    .execute();
+      .where(eq(citiesTable.id, 1))
+      .leftJoin(usersTable, (cities, users) => onEq(cities.userId, users.id))
+      .execute();
 
 const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
 ```
+### Another join examples with different callback ON statements
+```typescript
+await citiesTable.select()
+  .where(eq(citiesTable.location, 'q'))
+  .leftJoin(usersTable, (cities, _users) => eq(cities.id, 13))
+  .execute();
+// Join statement generated from query
+// LEFT JOIN users AS users_1
+// ON cities."id"=$1
+// WHERE cities."page"=$2
+//
+// Values: [13, 'q']
+
+await citiesTable.select()
+  .leftJoin(usersTable, (cities, _users) => and([
+    eq(cities.id, 13), notEq(cities.id, 14),
+  ]))
+  .execute();
+// Join statement generated from query
+// LEFT JOIN users AS users_1
+// ON (cities."id"=$1 and cities."id"!=$2)
+//
+// Values: [13, 14]
+
+await citiesTable.select()
+  .where(eq(citiesTable.location, 'location'))
+  .leftJoin(usersTable, (_cities, _users) => raw('<custom expression after ON statement>'))
+  .execute();
+// Join statement generated from query
+// LEFT JOIN users AS users_1
+// ON <custom expression after ON statement>
+// WHERE cities."page"=$1
+// 
+// Values: ['location']
+```
 
 
 ## Migrations

package/builders/aggregators/abstractAggregator.js

@@ -16,7 +16,7 @@ class Aggregator {
                     selectFields.push('.');
                     selectFields.push(ecranate_1.ecranate(field.getColumnName()));
                     selectFields.push(' AS ');
-                    selectFields.push(ecranate_1.ecranate(`${field.getAlias()}${id ? `_${id}` : ''}`));
+                    selectFields.push(ecranate_1.ecranate(`${table}_${field.getColumnName()}`));
                     selectFields.push(',');
                 }
             });

package/builders/aggregators/selectAggregator.d.ts

@@ -1,6 +1,7 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
 import { AbstractTable } from '../../tables';
+import { JoinType } from '../highLvlBuilders/joins/selectJoinBuilder';
 import Order from '../highLvlBuilders/order';
 import Join from '../joinBuilders/join';
 import Expr from '../requestBuilders/where/where';
@@ -25,6 +26,7 @@ export default class SelectAggregator extends Aggregator {
     orderBy: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectAggregator;
     distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined) => SelectAggregator;
     appendFrom: (tableName: string) => SelectAggregator;
+    join2: (joins: Array<JoinType<AbstractTable<any>>>) => SelectAggregator;
     join: (joins: {
         join: Join<any>;
         partial?: {

package/builders/aggregators/selectAggregator.js

@@ -24,10 +24,10 @@ class SelectAggregator extends abstractAggregator_1.default {
         this._joinCache = {};
         this.filters = (filters) => {
             if (filters) {
-                const queryBuilder = filters.toQuery({ position: 1, tableCache: this._joinCache, session: this._table.db.session() });
+                const queryBuilder = filters.toQuery({ position: this._values.length + 1, session: this._table.db.session() });
                 this._filters.push('WHERE ');
                 this._filters.push(queryBuilder.query);
-                this._values = queryBuilder.values;
+                this._values.push(...queryBuilder.values);
             }
             return this;
         };
@@ -64,7 +64,28 @@ class SelectAggregator extends abstractAggregator_1.default {
             this._from.push('FROM ');
             this._from.push(tableName);
             // this._from.push(`${tableName} AS ${tableName}_0`);
-            this._joinCache[tableName] = tableName;
+            // this._joinCache[tableName] = tableName;
+            return this;
+        };
+        this.join2 = (joins) => {
+            const tableFrom = this._table.tableName();
+            for (const [index, join] of joins.entries()) {
+                const { table: tableToName, originalName, onExpression, type, columns, } = join;
+                const selectString = this.generateSelectArray(tableToName, Object.values(columns)).join('');
+                this._fields.push(', ');
+                this._fields.push(selectString);
+                this._join.push('\n');
+                this._join.push(type);
+                this._join.push(' ');
+                this._join.push(originalName);
+                this._join.push(' ');
+                this._join.push(`AS ${tableToName}`);
+                this._join.push('\n');
+                this._join.push('ON ');
+                const joinExpr = onExpression.toQuery({ position: this._values.length + 1, session: this._table.db.session() });
+                this._values.push(...joinExpr.values);
+                this._join.push(joinExpr.query);
+            }
             return this;
         };
         // Add select generator for second table also

package/builders/highLvlBuilders/abstractRequestBuilder.d.ts

@@ -4,9 +4,8 @@ import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel } from '../../tables/inferTypes';
-export default abstract class TableRequestBuilder<TTable extends AbstractTable<TTable>, TPartial extends {
-    [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>;
-} = {}> {
+import { EmptyPartial } from './joins/selectJoinBuilder';
+export default abstract class TableRequestBuilder<TTable extends AbstractTable<TTable>, TPartial extends EmptyPartial<TTable>> {
     protected _table: TTable;
     protected _session: ISession;
     protected _mappedServiceToDb: {
@@ -21,6 +20,7 @@ export default abstract class TableRequestBuilder<TTable extends AbstractTable<T
     /**
      * Current function will return an element only if response is of length 1
      * If there are more or less than 1 element, will throw an Error
+     * @deprecated Use `.execute()` or `.all()` instead
      */
     findOne: () => Promise<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>;
     protected abstract _execute(): Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>>;

package/builders/highLvlBuilders/abstractRequestBuilder.js

@@ -9,6 +9,7 @@ class TableRequestBuilder {
         /**
          * Current function will return an element only if response is of length 1
          * If there are more or less than 1 element, will throw an Error
+         * @deprecated Use `.execute()` or `.all()` instead
          */
         this.findOne = async () => {
             const executionRes = await this._execute();

package/builders/highLvlBuilders/joins/joinBuilderResponse.d.ts

@@ -0,0 +1,8 @@
+import AbstractTable from '@/tables/abstractTable';
+import { FullOrPartial } from '@/tables/inferTypes';
+export default class JoinBuilderResponses<TResponses extends FullOrPartial<AbstractTable<any>, any>[]> {
+    private responses;
+    private responsesType;
+    constructor(responses: TResponses[]);
+    map: <M>(imac: (...args_0: TResponses) => M) => M[];
+}

package/builders/highLvlBuilders/joins/joinBuilderResponse.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class JoinBuilderResponses {
+    constructor(responses) {
+        this.responses = responses;
+        this.map = (imac) => {
+            const objects = new Array();
+            for (let i = 0; i < this.responses[0].length; i += 1) {
+                const responses = this.responses.map((res) => res[i]);
+                objects.push(imac(...responses));
+            }
+            return objects;
+        };
+    }
+}
+exports.default = JoinBuilderResponses;

package/builders/highLvlBuilders/joins/proxies/joinProxies.d.ts

@@ -0,0 +1,16 @@
+import AbstractTable from '@/tables/abstractTable';
+import ColumnType from '../../../../columns/types/columnType';
+import { AbstractColumn } from '../../../../columns/column';
+export declare class JoinedColumn<TJoinedTableColumn extends AbstractColumn<ColumnType>> implements ProxyHandler<TJoinedTableColumn> {
+    private tableObj;
+    private aliasCounter;
+    private parentName;
+    constructor(tableObj: any, aliasCounter: number);
+    get(columnObj: TJoinedTableColumn, prop: string): (() => string) | TJoinedTableColumn[keyof TJoinedTableColumn];
+}
+export declare class JoinedHandler<TJoinedTable extends AbstractTable<TJoinedTable>> implements ProxyHandler<TJoinedTable> {
+    private aliasCounter;
+    private tableName;
+    constructor(aliasCounter: number);
+    get(tableObj: TJoinedTable, prop: string | symbol, receiver: any): any;
+}

package/builders/highLvlBuilders/joins/proxies/joinProxies.js

@@ -0,0 +1,47 @@
+"use strict";
+/* eslint-disable max-classes-per-file */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinedHandler = exports.JoinedColumn = void 0;
+const column_1 = require("../../../../columns/column");
+class JoinedColumn {
+    constructor(tableObj, aliasCounter) {
+        this.tableObj = tableObj;
+        this.aliasCounter = aliasCounter;
+        this.parentName = 'getParentName';
+    }
+    get(columnObj, prop) {
+        if (prop === this.parentName) {
+            return () => `${this.tableObj.tableName()}_${this.aliasCounter}`;
+        }
+        return columnObj[prop];
+    }
+}
+exports.JoinedColumn = JoinedColumn;
+class JoinedHandler {
+    constructor(aliasCounter) {
+        this.aliasCounter = aliasCounter;
+        this.tableName = 'tableName';
+    }
+    get(tableObj, prop, receiver) {
+        if (prop === this.tableName) {
+            return () => `${tableObj.tableName()}_${this.aliasCounter}`;
+        }
+        const columnProp = tableObj[prop];
+        if (columnProp instanceof column_1.AbstractColumn) {
+            return new Proxy(columnProp, new JoinedColumn(tableObj, this.aliasCounter));
+        }
+        if (prop === 'mapServiceToDb') {
+            return () => Object.getOwnPropertyNames(tableObj)
+                .reduce((res, fieldName) => {
+                const field1 = tableObj[fieldName];
+                if (field1 instanceof column_1.AbstractColumn) {
+                    const field = new Proxy(field1, new JoinedColumn(tableObj, this.aliasCounter));
+                    res[fieldName] = field;
+                }
+                return res;
+            }, {});
+        }
+        return tableObj[prop];
+    }
+}
+exports.JoinedHandler = JoinedHandler;

package/builders/highLvlBuilders/joins/selectJoinBuilder.d.ts

@@ -0,0 +1,43 @@
+import { ExtractPartialObjectFromColumns, FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+import AbstractTable from '../../../tables/abstractTable';
+import BaseLogger from '../../../logger/abstractLogger';
+import ColumnType from '../../../columns/types/columnType';
+import { AbstractColumn } from '../../../columns/column';
+import Expr from '../../requestBuilders/where/where';
+import Order from '../order';
+import JoinBuilderResponses from './joinBuilderResponse';
+export interface JoinType<T extends AbstractTable<T>> {
+    table: string;
+    columns: ExtractPartialObjectFromColumns<T>;
+    onExpression: Expr;
+    type: string;
+    originalName: string;
+}
+export declare type TableIfPartialIsUndefined<TPartial, TJoinedTableMapped> = TPartial extends undefined ? TJoinedTableMapped : TPartial;
+export declare type EmptyPartial<T extends AbstractTable<T>> = PartialFor<T> | undefined;
+export default class JoinBuilder<TJoins extends {
+    [name: string]: any;
+}[], TJoinsResponses extends FullOrPartial<AbstractTable<any>, any>[]> {
+    private joins;
+    private aliasCounter;
+    private rootTable;
+    private _filter;
+    private _props;
+    private _orderBy?;
+    private _order?;
+    private _distinct?;
+    private _partial?;
+    private _logger?;
+    private joinedTables;
+    private joinResponses;
+    constructor(joins: TJoins, onTableOriginalName: string, aliasCounter: number, onExpression: Expr, onTable: AbstractTable<any>, type: string, rootTable: AbstractTable<any>, _filter: Expr, _props: {
+        limit?: number;
+        offset?: number;
+    }, _orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, _order?: Order | undefined, _distinct?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, _partial?: any, _logger?: BaseLogger | undefined);
+    innerJoin<TJoinedTable extends AbstractTable<TJoinedTable>, TPartial extends EmptyPartial<TJoinedTable> = undefined>(value: TJoinedTable, callback: (...args: [...TJoins, TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TJoinedTable>>]) => Expr, partial?: TPartial): JoinBuilder<[...TJoins, TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TJoinedTable>>], [...TJoinsResponses, FullOrPartial<TJoinedTable, TPartial>]>;
+    leftJoin<TJoinedTable extends AbstractTable<TJoinedTable>, TPartial extends EmptyPartial<TJoinedTable> = undefined>(value: TJoinedTable, callback: (...args: [...TJoins, TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TJoinedTable>>]) => Expr, partial?: TPartial): JoinBuilder<[...TJoins, TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TJoinedTable>>], [...TJoinsResponses, FullOrPartial<TJoinedTable, TPartial>]>;
+    rightJoin<TJoinedTable extends AbstractTable<TJoinedTable>, TPartial extends EmptyPartial<TJoinedTable> = undefined>(value: TJoinedTable, callback: (...args: [...TJoins, TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TJoinedTable>>]) => Expr, partial?: TPartial): JoinBuilder<[...TJoins, TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TJoinedTable>>], [...TJoinsResponses, FullOrPartial<TJoinedTable, TPartial>]>;
+    fullJoin<TJoinedTable extends AbstractTable<TJoinedTable>, TPartial extends EmptyPartial<TJoinedTable> = undefined>(value: TJoinedTable, callback: (...args: [...TJoins, TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TJoinedTable>>]) => Expr, partial?: TPartial): JoinBuilder<[...TJoins, TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TJoinedTable>>], [...TJoinsResponses, FullOrPartial<TJoinedTable, TPartial>]>;
+    execute(): Promise<JoinBuilderResponses<TJoinsResponses>>;
+    private join;
+}

package/builders/highLvlBuilders/joins/selectJoinBuilder.js

@@ -0,0 +1,109 @@
+"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 responseMapper_1 = __importDefault(require("../../../mappers/responseMapper"));
+const builderError_1 = __importStar(require("../../../errors/builderError"));
+const select_1 = __importDefault(require("../../lowLvlBuilders/selects/select"));
+const joinBuilderResponse_1 = __importDefault(require("./joinBuilderResponse"));
+const joinProxies_1 = require("./proxies/joinProxies");
+class JoinBuilder {
+    constructor(joins, onTableOriginalName, aliasCounter, onExpression, onTable, type, rootTable, _filter, _props, _orderBy, _order, _distinct, _partial, _logger) {
+        this.joins = joins;
+        this.aliasCounter = aliasCounter;
+        this.rootTable = rootTable;
+        this._filter = _filter;
+        this._props = _props;
+        this._orderBy = _orderBy;
+        this._order = _order;
+        this._distinct = _distinct;
+        this._partial = _partial;
+        this._logger = _logger;
+        this.joinedTables = [];
+        this.joinedTables.push({
+            table: onTable.tableName(),
+            columns: joins[1],
+            originalName: onTableOriginalName,
+            onExpression,
+            type,
+        });
+    }
+    innerJoin(value, callback, partial) {
+        return this.join(value, callback, 'INNER JOIN', partial);
+    }
+    leftJoin(value, callback, partial) {
+        return this.join(value, callback, 'LEFT JOIN', partial);
+    }
+    rightJoin(value, callback, partial) {
+        return this.join(value, callback, 'RIGHT JOIN', partial);
+    }
+    fullJoin(value, callback, partial) {
+        return this.join(value, callback, 'FULL JOIN', partial);
+    }
+    async execute() {
+        const queryBuilder = select_1.default
+            .from(this.rootTable, this._partial)
+            .distinct(this._distinct)
+            .joined2(this.joinedTables)
+            .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.rootTable.tableName(), Object.values(this.rootTable.mapServiceToDb()), e, this.rootTable.db.session(), this._filter);
+        }
+        if (this._logger) {
+            this._logger.info(`Selecting from ${this.rootTable.tableName()} using query:\n ${query}`);
+            this._logger.info(`Values for query:\n ${values}`);
+        }
+        const result = await this.rootTable.db.session().execute(query, values);
+        const mappedResponse = this.joins.map((joinedTable) => responseMapper_1.default.map(joinedTable, result));
+        return new joinBuilderResponse_1.default(mappedResponse);
+    }
+    join(value, callback, joinType, partial) {
+        this.aliasCounter += 1;
+        const valueAsProxy = new Proxy(value, new joinProxies_1.JoinedHandler(this.aliasCounter));
+        if (partial) {
+            for (const key of Object.keys(partial)) {
+                // eslint-disable-next-line no-param-reassign
+                partial[key] = new Proxy(partial[key], new joinProxies_1.JoinedColumn(value, this.aliasCounter));
+            }
+        }
+        const obj = partial ? partial
+            : valueAsProxy.mapServiceToDb();
+        const onExpression = callback(...this.joins, obj);
+        this.joins.push(partial !== null && partial !== void 0 ? partial : valueAsProxy.mapServiceToDb());
+        this.joinedTables.push({
+            table: valueAsProxy.tableName(), columns: obj, originalName: value.tableName(), onExpression, type: joinType,
+        });
+        return this;
+    }
+}
+exports.default = JoinBuilder;

package/builders/highLvlBuilders/selectRequestBuilder.d.ts

@@ -4,14 +4,13 @@ import DB from '../../db/db';
 import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
-import { ExtractModel, PartialFor } from '../../tables/inferTypes';
+import { ExtractModel, ExtractPartialObjectFromColumns, FullOrPartial, PartialFor } from '../../tables/inferTypes';
 import SelectTRBWithJoin from '../joinBuilders/builders/selectWithJoin';
 import Expr from '../requestBuilders/where/where';
 import TableRequestBuilder from './abstractRequestBuilder';
+import JoinBuilder, { EmptyPartial, TableIfPartialIsUndefined } from './joins/selectJoinBuilder';
 import Order from './order';
-export default class SelectTRB<TTable extends AbstractTable<TTable>, TPartial extends {
-    [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>;
-} = {}> extends TableRequestBuilder<TTable, TPartial> {
+export default class SelectTRB<TTable extends AbstractTable<TTable>, TPartial extends EmptyPartial<TTable> = undefined> extends TableRequestBuilder<TTable, TPartial> {
     protected _filter: Expr;
     private props;
     private __orderBy?;
@@ -25,23 +24,40 @@ export default class SelectTRB<TTable extends AbstractTable<TTable>, TPartial ex
         limit?: number;
         offset?: number;
     }, table: AbstractTable<TTable>, logger?: BaseLogger, partial?: TPartial);
+    private join;
+    innerJoin<TJoinedTable extends AbstractTable<TJoinedTable>, TJoinedPartial extends EmptyPartial<TJoinedTable> = undefined>(value: TJoinedTable, callback: (...args: [TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TTable>>, TableIfPartialIsUndefined<TJoinedPartial, ExtractPartialObjectFromColumns<TJoinedTable>>]) => Expr, partial?: TJoinedPartial): JoinBuilder<[TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TTable>>, TableIfPartialIsUndefined<TJoinedPartial, ExtractPartialObjectFromColumns<TJoinedTable>>], [FullOrPartial<TTable, TPartial>, FullOrPartial<TJoinedTable, TJoinedPartial>]>;
+    leftJoin<TJoinedTable extends AbstractTable<TJoinedTable>, TJoinedPartial extends EmptyPartial<TJoinedTable> = undefined>(value: TJoinedTable, callback: (...args: [TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TTable>>, TableIfPartialIsUndefined<TJoinedPartial, ExtractPartialObjectFromColumns<TJoinedTable>>]) => Expr, partial?: TJoinedPartial): JoinBuilder<[TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TTable>>, TableIfPartialIsUndefined<TJoinedPartial, ExtractPartialObjectFromColumns<TJoinedTable>>], [FullOrPartial<TTable, TPartial>, FullOrPartial<TJoinedTable, TJoinedPartial>]>;
+    rightJoin<TJoinedTable extends AbstractTable<TJoinedTable>, TJoinedPartial extends EmptyPartial<TJoinedTable> = undefined>(value: TJoinedTable, callback: (...args: [TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TTable>>, TableIfPartialIsUndefined<TJoinedPartial, ExtractPartialObjectFromColumns<TJoinedTable>>]) => Expr, partial?: TJoinedPartial): JoinBuilder<[TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TTable>>, TableIfPartialIsUndefined<TJoinedPartial, ExtractPartialObjectFromColumns<TJoinedTable>>], [FullOrPartial<TTable, TPartial>, FullOrPartial<TJoinedTable, TJoinedPartial>]>;
+    fullJoin<TJoinedTable extends AbstractTable<TJoinedTable>, TJoinedPartial extends EmptyPartial<TJoinedTable> = undefined>(value: TJoinedTable, callback: (...args: [TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TTable>>, TableIfPartialIsUndefined<TJoinedPartial, ExtractPartialObjectFromColumns<TJoinedTable>>]) => Expr, partial?: TJoinedPartial): JoinBuilder<[TableIfPartialIsUndefined<TPartial, ExtractPartialObjectFromColumns<TTable>>, TableIfPartialIsUndefined<TJoinedPartial, ExtractPartialObjectFromColumns<TJoinedTable>>], [FullOrPartial<TTable, TPartial>, FullOrPartial<TJoinedTable, TJoinedPartial>]>;
     where: (expr: Expr) => SelectTRB<TTable, TPartial>;
     orderBy<TColumnType extends ColumnType>(callback: (table: TTable) => AbstractColumn<TColumnType, boolean, boolean>, order: Order): SelectTRB<TTable, TPartial>;
     distinct: (column: AbstractColumn<ColumnType<any>, boolean, boolean>) => SelectTRB<TTable, TPartial>;
     limit: (limit: number) => SelectTRB<TTable, TPartial>;
     offset: (offset: number) => SelectTRB<TTable, TPartial>;
-    innerJoin<TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
+    /**
+    * @deprecated Since version 0.11.0. Will be deleted in version 0.12.0. Use {@link innerJoinV2()} instead
+    */
+    innerJoinV1<TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable>>(table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial>;
-    leftJoin<TColumn extends ColumnType<any>, IToColumn extends ColumnType<any>, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, PartialFor<TTable>, IToPartial>;
+    /**
+    * @deprecated Since version 0.11.0. Will be deleted in version 0.12.0. Use {@link leftJoin()} instead
+    */
+    leftJoinV1<TColumn extends ColumnType<any>, IToColumn extends ColumnType<any>, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean, TTable>, to: (table: IToTable) => AbstractColumn<IToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial>;
-    rightJoin<TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean, TTable>, to: (table: IToTable) => AbstractColumn<IToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, PartialFor<TTable>, IToPartial>;
+    /**
+    * @deprecated Since version 0.11.0. Will be deleted in version 0.12.0. Use {@link rightJoin()} instead
+    */
+    rightJoinV1<TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial>;
-    fullJoin<TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, PartialFor<TTable>, IToPartial>;
+    /**
+    * @deprecated Since version 0.11.0. Will be deleted in version 0.12.0. Use {@link fullJoin()} instead
+    */
+    fullJoinV1<TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial>;
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, PartialFor<TTable>, IToPartial>;
     execute: () => Promise<([keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>)[]>;
     protected _execute: () => Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>>;
 }

package/builders/highLvlBuilders/selectRequestBuilder.js

@@ -28,6 +28,8 @@ const responseMapper_1 = __importDefault(require("../../mappers/responseMapper")
 const selectWithJoin_1 = __importDefault(require("../joinBuilders/builders/selectWithJoin"));
 const join_1 = require("../joinBuilders/join");
 const abstractRequestBuilder_1 = __importDefault(require("./abstractRequestBuilder"));
+const joinProxies_1 = require("./joins/proxies/joinProxies");
+const selectJoinBuilder_1 = __importDefault(require("./joins/selectJoinBuilder"));
 class SelectTRB extends abstractRequestBuilder_1.default {
     constructor(session, mappedServiceToDb, props, table, logger, partial) {
         super(table, session, mappedServiceToDb, logger);
@@ -83,6 +85,33 @@ class SelectTRB extends abstractRequestBuilder_1.default {
         this.props = props;
         this.__partial = partial;
     }
+    join(value, callback, joinType, partial) {
+        const valueAsProxy = new Proxy(value, new joinProxies_1.JoinedHandler(1));
+        if (partial) {
+            for (const key of Object.keys(partial)) {
+                // eslint-disable-next-line no-param-reassign
+                partial[key] = new Proxy(partial[key], new joinProxies_1.JoinedColumn(value, 1));
+            }
+        }
+        const obj = this.__partial ? this.__partial
+            : this._table.mapServiceToDb();
+        const obj1 = partial ? partial
+            : valueAsProxy.mapServiceToDb();
+        const joinExpression = callback(obj, obj1);
+        return new selectJoinBuilder_1.default([obj, obj1], value.tableName(), 1, joinExpression, valueAsProxy, joinType, this._table, this._filter, this.props, this.__orderBy, this.__order, this.__distinct, this.__partial, this._logger);
+    }
+    innerJoin(value, callback, partial) {
+        return this.join(value, callback, 'INNER JOIN', partial);
+    }
+    leftJoin(value, callback, partial) {
+        return this.join(value, callback, 'LEFT JOIN', partial);
+    }
+    rightJoin(value, callback, partial) {
+        return this.join(value, callback, 'RIGHT JOIN', partial);
+    }
+    fullJoin(value, callback, partial) {
+        return this.join(value, callback, 'FULL JOIN', partial);
+    }
     orderBy(callback, order) {
         this.__orderBy = callback(this._table);
         this.__order = order;
@@ -93,7 +122,10 @@ class SelectTRB extends abstractRequestBuilder_1.default {
     //   this.__groupBy = callback(this.__table);
     //   return this;
     // }
-    innerJoin(table, from, to, partial) {
+    /**
+    * @deprecated Since version 0.11.0. Will be deleted in version 0.12.0. Use {@link innerJoinV2()} instead
+    */
+    innerJoinV1(table, from, to, partial) {
         const toTable = this._table.db.create(table);
         const fromColumn = from(this._table);
         const toColumn = to(toTable);
@@ -101,7 +133,10 @@ class SelectTRB extends abstractRequestBuilder_1.default {
             .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, this.__partial, partial, this._logger);
     }
-    leftJoin(table, from, to, partial) {
+    /**
+    * @deprecated Since version 0.11.0. Will be deleted in version 0.12.0. Use {@link leftJoin()} instead
+    */
+    leftJoinV1(table, from, to, partial) {
         const toTable = this._table.db.create(table);
         const fromColumn = from(this._table);
         const toColumn = to(toTable);
@@ -109,7 +144,10 @@ class SelectTRB extends abstractRequestBuilder_1.default {
             .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, this.__partial, partial, this._logger);
     }
-    rightJoin(table, from, to, partial) {
+    /**
+    * @deprecated Since version 0.11.0. Will be deleted in version 0.12.0. Use {@link rightJoin()} instead
+    */
+    rightJoinV1(table, from, to, partial) {
         const toTable = this._table.db.create(table);
         const fromColumn = from(this._table);
         const toColumn = to(toTable);
@@ -117,7 +155,10 @@ class SelectTRB extends abstractRequestBuilder_1.default {
             .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, this.__partial, partial, this._logger);
     }
-    fullJoin(table, from, to, partial) {
+    /**
+    * @deprecated Since version 0.11.0. Will be deleted in version 0.12.0. Use {@link fullJoin()} instead
+    */
+    fullJoinV1(table, from, to, partial) {
         const toTable = this._table.db.create(table);
         const fromColumn = from(this._table);
         const toColumn = to(toTable);

package/builders/index.d.ts

@@ -2,6 +2,9 @@ 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 * from './highLvlBuilders/joins/selectJoinBuilder';
+export { default as JoinBuilderResponses } from './highLvlBuilders/joins/joinBuilderResponse';
+export * from './highLvlBuilders/joins/proxies/joinProxies';
 export { default as to } from './joinBuilders/static';
 export { default as JoinWith } from './joinBuilders/joinWith';
 export { default as Join } from './joinBuilders/join';