drizzle-orm 0.11.0 → 0.11.1

package/README.md

@@ -343,8 +343,8 @@ const usersTable = new UsersTable(db);
 const citiesTable = new CitiesTable(db);
 
 const userWithCities = await citiesTable.select()
-  .where(eq(citiesTable.id, 1))
-  .leftJoin(usersTable, (cities, users) => onEq(cities.userId, users.id))
+  .leftJoin(usersTable, (cities, users) => eq(cities.userId, users.id))
+  .where((cities, users) => eq(cities.id, 1))
   .execute();
 
 const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
@@ -353,11 +353,11 @@ const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user
 ### Join Many-To-Many Tables
 ##### Join User Groups with Users, using many-to-many table
 ```typescript
-  const usersWithUserGroups = await usersToUserGroupsTable.select()
-      .where(eq(userGroupsTable.id, 1))
-      .leftJoin(usersTable, (usersToUserGroups, users) => onEq(usersToUserGroups.userId, users.id))
-      .leftJoin(userGroupsTable, (usersToUserGroups, _users, userGroups) => onEq(usersToUserGroups.groupId, userGroups.id))
-      .execute();
+const usersWithUserGroups = await usersToUserGroupsTable.select()
+  .leftJoin(usersTable, (usersToUserGroups, users) => eq(usersToUserGroups.userId, users.id))
+  .leftJoin(userGroupsTable, (usersToUserGroups, _users, userGroups) => eq(usersToUserGroups.groupId, userGroups.id))
+  .where((usersToUserGroups, _users, userGroups) => eq(userGroups.id, 1))
+  .execute();
 ```
 ### Join using partial field select
 ##### Join Cities with Users getting only needed fields form request
@@ -366,8 +366,8 @@ const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user
       id: citiesTable.id,
       userId: citiesTable.userId,
     })
-      .where(eq(citiesTable.id, 1))
-      .leftJoin(usersTable, (cities, users) => onEq(cities.userId, users.id))
+      .leftJoin(usersTable, (cities, users) => eq(cities.userId, users.id))
+      .where((cities, users) => eq(cities.id, 1))
       .execute();
 
 const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
@@ -375,8 +375,8 @@ 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))
+  .where((cities, _users) => eq(cities.location, 'q'))
   .execute();
 // Join statement generated from query
 // LEFT JOIN users AS users_1
@@ -397,8 +397,8 @@ await citiesTable.select()
 // Values: [13, 14]
 
 await citiesTable.select()
-  .where(eq(citiesTable.location, 'location'))
   .leftJoin(usersTable, (_cities, _users) => raw('<custom expression after ON statement>'))
+  .where((cities, _users) => eq(cities.location, 'location'))
   .execute();
 // Join statement generated from query
 // LEFT JOIN users AS users_1

package/builders/aggregators/selectAggregator.d.ts

@@ -3,7 +3,6 @@ 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';
 import Aggregator from './abstractAggregator';
 export default class SelectAggregator extends Aggregator {
@@ -26,14 +25,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?: {
-            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
-        } | undefined;
-        id?: number | undefined;
-    }[]) => SelectAggregator;
+    join: (joins: Array<JoinType<AbstractTable<any>>>) => SelectAggregator;
     buildQuery: () => {
         query: string;
         values: Array<any>;

package/builders/aggregators/selectAggregator.js

@@ -7,8 +7,6 @@ const ecranate_1 = require("../../utils/ecranate");
 const order_1 = __importDefault(require("../highLvlBuilders/order"));
 const abstractAggregator_1 = __importDefault(require("./abstractAggregator"));
 class SelectAggregator extends abstractAggregator_1.default {
-    // public constructor(table: AbstractTable<any>);
-    // public constructor(table: AbstractTable<any>, partial: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>})
     constructor(table, partial) {
         super(table, partial);
         this._from = [];
@@ -67,7 +65,7 @@ class SelectAggregator extends abstractAggregator_1.default {
             // this._joinCache[tableName] = tableName;
             return this;
         };
-        this.join2 = (joins) => {
+        this.join = (joins) => {
             const tableFrom = this._table.tableName();
             for (const [index, join] of joins.entries()) {
                 const { table: tableToName, originalName, onExpression, type, columns, } = join;
@@ -88,58 +86,6 @@ class SelectAggregator extends abstractAggregator_1.default {
             }
             return this;
         };
-        // Add select generator for second table also
-        this.join = (joins) => {
-            // const cache: {[tableName: string]: string} = {};
-            joins.forEach((joinObject) => {
-                if (joinObject) {
-                    const tableFrom = joinObject.join.fromColumn.getParentName();
-                    const tableTo = joinObject.join.toColumn.getParentName();
-                    const { type } = joinObject.join;
-                    let fromAlias = '';
-                    if (this._joinCache[tableFrom]) {
-                        fromAlias = this._joinCache[tableFrom];
-                    }
-                    else {
-                        fromAlias = `${tableFrom}${joinObject.id ? `_${joinObject.id}` : ''}`;
-                        this._joinCache[tableFrom] = fromAlias;
-                    }
-                    let selectString;
-                    if (joinObject.partial) {
-                        selectString = this.generateSelectArray(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`, Object.values(joinObject.partial), joinObject.id).join('');
-                    }
-                    else {
-                        selectString = this.generateSelectArray(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`, Object.values(joinObject.join.mappedServiceToDb), joinObject.id).join('');
-                    }
-                    this._fields.push(', ');
-                    this._fields.push(selectString);
-                    this._join.push('\n');
-                    this._join.push(type);
-                    this._join.push(' ');
-                    this._join.push(tableTo);
-                    this._join.push(' ');
-                    this._join.push(`AS ${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`);
-                    this._joinCache[tableTo] = `${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`;
-                    this._join.push('\n');
-                    this._join.push('ON ');
-                    this._join.push(fromAlias);
-                    // if (this._joinCache[tableFrom]) {
-                    //   this._join.push(this._joinCache[tableFrom]);
-                    // } else {
-                    //   this._join.push(tableFrom);
-                    //   this._joinCache[tableFrom] = `${tableFrom}${joinObject.id ? `_${joinObject.id}` : ''}`;
-                    // }
-                    this._join.push('.');
-                    this._join.push(joinObject.join.fromColumn.getColumnName());
-                    this._join.push(' = ');
-                    this._join.push(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`);
-                    // this._join.push(toAlias);
-                    this._join.push('.');
-                    this._join.push(joinObject.join.toColumn.getColumnName());
-                }
-            });
-            return this;
-        };
         this.buildQuery = () => {
             this._select.push(this._distinct.join(''));
             this._select.push(this._fields.join(''));

package/builders/aggregators/selectAggregatorV1.d.ts

@@ -0,0 +1,39 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { AbstractTable } from '../../tables';
+import Order from '../highLvlBuilders/order';
+import Join from '../joinBuilders/join';
+import Expr from '../requestBuilders/where/where';
+import Aggregator from './abstractAggregator';
+export default class SelectAggregatorV1 extends Aggregator {
+    private _from;
+    private _filters;
+    private _select;
+    private _join;
+    private _limit;
+    private _offset;
+    private _distinct;
+    private _orderBy;
+    private _values;
+    private _joinCache;
+    constructor(table: AbstractTable<any>, partial?: {
+        [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>;
+    });
+    filters: (filters: Expr) => SelectAggregatorV1;
+    limit: (limit?: number | undefined) => SelectAggregatorV1;
+    offset: (offset?: number | undefined) => SelectAggregatorV1;
+    orderBy: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectAggregatorV1;
+    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined) => SelectAggregatorV1;
+    appendFrom: (tableName: string) => SelectAggregatorV1;
+    join: (joins: {
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        } | undefined;
+        id?: number | undefined;
+    }[]) => SelectAggregatorV1;
+    buildQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/builders/aggregators/selectAggregatorV1.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ecranate_1 = require("../../utils/ecranate");
+const order_1 = __importDefault(require("../highLvlBuilders/order"));
+const abstractAggregator_1 = __importDefault(require("./abstractAggregator"));
+class SelectAggregatorV1 extends abstractAggregator_1.default {
+    // public constructor(table: AbstractTable<any>);
+    // public constructor(table: AbstractTable<any>, partial: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>})
+    constructor(table, partial) {
+        super(table, partial);
+        this._from = [];
+        this._filters = [];
+        this._select = ['SELECT'];
+        this._join = [];
+        this._limit = [];
+        this._offset = [];
+        this._distinct = [];
+        // private _groupBy: Array<string> = [];
+        this._orderBy = [];
+        this._values = [];
+        this._joinCache = {};
+        this.filters = (filters) => {
+            if (filters) {
+                const queryBuilder = filters.toQueryV1({ position: 1, tableCache: this._joinCache, session: this._table.db.session() });
+                this._filters.push('WHERE ');
+                this._filters.push(queryBuilder.query);
+                this._values = queryBuilder.values;
+            }
+            return this;
+        };
+        this.limit = (limit) => {
+            if (limit) {
+                this._limit.push('LIMIT ');
+                this._limit.push(limit.toString());
+            }
+            return this;
+        };
+        this.offset = (offset) => {
+            if (offset) {
+                this._offset.push('OFFSET ');
+                this._offset.push(offset.toString());
+            }
+            return this;
+        };
+        this.orderBy = (column, order) => {
+            if (column !== null && column !== undefined) {
+                this._orderBy.push('ORDER BY ');
+                const columnParent = this._joinCache[column.getParent().tableName()] ? this._joinCache[column.getParent().tableName()] : column.getParent().tableName();
+                this._orderBy.push(`${columnParent}.${ecranate_1.ecranate(column.getColumnName())} `);
+                this._orderBy.push(order_1.default[order]);
+            }
+            return this;
+        };
+        this.distinct = (column) => {
+            if (column) {
+                this._distinct.push(` DISTINCT ON(${column.getParent().tableName()}.${ecranate_1.ecranate(column.getColumnName())}) `);
+            }
+            return this;
+        };
+        this.appendFrom = (tableName) => {
+            this._from.push('FROM ');
+            this._from.push(tableName);
+            // this._from.push(`${tableName} AS ${tableName}_0`);
+            this._joinCache[tableName] = tableName;
+            return this;
+        };
+        // Add select generator for second table also
+        this.join = (joins) => {
+            // const cache: {[tableName: string]: string} = {};
+            joins.forEach((joinObject) => {
+                if (joinObject) {
+                    const tableFrom = joinObject.join.fromColumn.getParentName();
+                    const tableTo = joinObject.join.toColumn.getParentName();
+                    const { type } = joinObject.join;
+                    let fromAlias = '';
+                    if (this._joinCache[tableFrom]) {
+                        fromAlias = this._joinCache[tableFrom];
+                    }
+                    else {
+                        fromAlias = `${tableFrom}${joinObject.id ? `_${joinObject.id}` : ''}`;
+                        this._joinCache[tableFrom] = fromAlias;
+                    }
+                    let selectString;
+                    if (joinObject.partial) {
+                        selectString = this.generateSelectArray(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`, Object.values(joinObject.partial), joinObject.id).join('');
+                    }
+                    else {
+                        selectString = this.generateSelectArray(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`, Object.values(joinObject.join.mappedServiceToDb), joinObject.id).join('');
+                    }
+                    this._fields.push(', ');
+                    this._fields.push(selectString);
+                    this._join.push('\n');
+                    this._join.push(type);
+                    this._join.push(' ');
+                    this._join.push(tableTo);
+                    this._join.push(' ');
+                    this._join.push(`AS ${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`);
+                    this._joinCache[tableTo] = `${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`;
+                    this._join.push('\n');
+                    this._join.push('ON ');
+                    this._join.push(fromAlias);
+                    // if (this._joinCache[tableFrom]) {
+                    //   this._join.push(this._joinCache[tableFrom]);
+                    // } else {
+                    //   this._join.push(tableFrom);
+                    //   this._joinCache[tableFrom] = `${tableFrom}${joinObject.id ? `_${joinObject.id}` : ''}`;
+                    // }
+                    this._join.push('.');
+                    this._join.push(joinObject.join.fromColumn.getColumnName());
+                    this._join.push(' = ');
+                    this._join.push(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`);
+                    // this._join.push(toAlias);
+                    this._join.push('.');
+                    this._join.push(joinObject.join.toColumn.getColumnName());
+                }
+            });
+            return this;
+        };
+        this.buildQuery = () => {
+            this._select.push(this._distinct.join(''));
+            this._select.push(this._fields.join(''));
+            this._select.push('\n');
+            this._select.push(this._from.join(''));
+            this._select.push('\n');
+            this._select.push(this._join.join(''));
+            if (this._join.length > 0) {
+                this._select.push('\n');
+            }
+            this._select.push(this._filters.join(''));
+            this._select.push('\n');
+            this._select.push(this._orderBy.join(''));
+            this._select.push('\n');
+            this._select.push(this._limit.join(''));
+            this._select.push('\n');
+            this._select.push(this._offset.join(''));
+            return { query: this._select.join(''), values: this._values };
+        };
+    }
+}
+exports.default = SelectAggregatorV1;

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

@@ -38,6 +38,7 @@ export default class JoinBuilder<TJoins extends {
     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>]>;
+    where: (callback: (...args_0: TJoins) => Expr) => this;
     execute(): Promise<JoinBuilderResponses<TJoinsResponses>>;
     private join;
 }

package/builders/highLvlBuilders/joins/selectJoinBuilder.js

@@ -40,6 +40,10 @@ class JoinBuilder {
         this._partial = _partial;
         this._logger = _logger;
         this.joinedTables = [];
+        this.where = (callback) => {
+            this._filter = callback(...this.joins);
+            return this;
+        };
         this.joinedTables.push({
             table: onTable.tableName(),
             columns: joins[1],
@@ -64,7 +68,7 @@ class JoinBuilder {
         const queryBuilder = select_1.default
             .from(this.rootTable, this._partial)
             .distinct(this._distinct)
-            .joined2(this.joinedTables)
+            .joined(this.joinedTables)
             .limit(this._props.limit)
             .offset(this._props.offset)
             .filteredBy(this._filter)

package/builders/highLvlBuilders/selectRequestBuilder.d.ts

@@ -29,7 +29,7 @@ export default class SelectTRB<TTable extends AbstractTable<TTable>, TPartial ex
     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>;
+    where: (expr: Expr) => Omit<this, 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin'>;
     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>;
@@ -39,25 +39,25 @@ export default class SelectTRB<TTable extends AbstractTable<TTable>, TPartial ex
     */
     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, PartialFor<TTable>, IToPartial>;
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial extends undefined ? {} : TPartial, 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, PartialFor<TTable>, IToPartial>;
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean, TTable>, to: (table: IToTable) => AbstractColumn<IToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial extends undefined ? {} : TPartial, 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, PartialFor<TTable>, IToPartial>;
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial extends undefined ? {} : TPartial, 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, PartialFor<TTable>, IToPartial>;
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TToColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial extends undefined ? {} : TPartial, 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/joinBuilders/builders/abstractJoinBuilder.js

@@ -37,7 +37,7 @@ class AbstractJoined {
         };
         this.execute = async () => {
             const queryBuilder = select_1.default
-                .from(this._table, this._partial)
+                .fromV1(this._table, this._partial)
                 .distinct(this._distinct)
                 .joined(this.joins())
                 .limit(this._props.limit)

package/builders/lowLvlBuilders/selects/select.d.ts

@@ -1,9 +1,12 @@
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import { AbstractTable } from '../../../tables';
-import SelectFrom from './selectFrom';
+import SelectFrom, { SelectFromV1 } from './selectFrom';
 export default class Select {
     static from: <TTable extends AbstractTable<TTable>, TType extends ColumnType<any>, TColumn extends AbstractColumn<TType, boolean, boolean, TTable>, T extends {
         [name: string]: TColumn;
     } = {}>(table: AbstractTable<TTable>, partial?: T | undefined) => SelectFrom;
+    static fromV1: <TTable extends AbstractTable<TTable>, TType extends ColumnType<any>, TColumn extends AbstractColumn<TType, boolean, boolean, TTable>, T extends {
+        [name: string]: TColumn;
+    } = {}>(table: AbstractTable<TTable>, partial?: T | undefined) => SelectFromV1;
 }

package/builders/lowLvlBuilders/selects/select.js

@@ -1,10 +1,30 @@
 "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 selectAggregatorV1_1 = __importDefault(require("../../aggregators/selectAggregatorV1"));
 const selectAggregator_1 = __importDefault(require("../../aggregators/selectAggregator"));
-const selectFrom_1 = __importDefault(require("./selectFrom"));
+const selectFrom_1 = __importStar(require("./selectFrom"));
 class Select {
 }
 exports.default = Select;
@@ -14,3 +34,9 @@ Select.from = (table, partial) => {
     aggregator.appendFrom(table.tableName());
     return new selectFrom_1.default(aggregator);
 };
+// eslint-disable-next-line max-len
+Select.fromV1 = (table, partial) => {
+    const aggregator = new selectAggregatorV1_1.default(table, partial);
+    aggregator.appendFrom(table.tableName());
+    return new selectFrom_1.SelectFromV1(aggregator);
+};

package/builders/lowLvlBuilders/selects/selectFrom.d.ts

@@ -1,29 +1,43 @@
-import { JoinType } from '@/builders/highLvlBuilders/joins/selectJoinBuilder';
-import AbstractTable from '@/tables/abstractTable';
+import AbstractTable from '../../../tables/abstractTable';
+import SelectAggregatorV1 from '../../aggregators/selectAggregatorV1';
+import { JoinType } from '../../highLvlBuilders/joins/selectJoinBuilder';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import SelectAggregator from '../../aggregators/selectAggregator';
 import Order from '../../highLvlBuilders/order';
 import Join from '../../joinBuilders/join';
 import Expr from '../../requestBuilders/where/where';
-import SelectJoined from './selectJoined';
-import WhereSelect from './whereSelect';
+import SelectJoined, { SelectJoinedV1 } from './selectJoined';
+import WhereSelect, { WhereSelectV1 } from './whereSelect';
 export default class SelectFrom {
     private _aggregator;
     constructor(aggregator: SelectAggregator);
+    joined: (joins: Array<JoinType<AbstractTable<any>>>) => SelectJoined;
+    limit: (limit?: number | undefined) => SelectFrom;
+    offset: (offset?: number | undefined) => SelectFrom;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectFrom;
+    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined) => SelectFrom;
+    filteredBy: (filters: Expr) => WhereSelect;
+    build: () => {
+        query: string;
+        values: any[];
+    };
+}
+export declare class SelectFromV1 {
+    private _aggregator;
+    constructor(aggregator: SelectAggregatorV1);
     joined: (joins: {
         join: Join<any>;
         partial?: {
             [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
         } | undefined;
         id?: number | undefined;
-    }[]) => SelectJoined;
-    joined2: (joins: Array<JoinType<AbstractTable<any>>>) => SelectJoined;
-    limit: (limit?: number | undefined) => SelectFrom;
-    offset: (offset?: number | undefined) => SelectFrom;
-    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectFrom;
-    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined) => SelectFrom;
-    filteredBy: (filters: Expr) => WhereSelect;
+    }[]) => SelectJoinedV1;
+    limit: (limit?: number | undefined) => SelectFromV1;
+    offset: (offset?: number | undefined) => SelectFromV1;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectFromV1;
+    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined) => SelectFromV1;
+    filteredBy: (filters: Expr) => WhereSelectV1;
     build: () => {
         query: string;
         values: any[];

package/builders/lowLvlBuilders/selects/selectFrom.js

@@ -1,14 +1,30 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const selectJoined_1 = __importDefault(require("./selectJoined"));
-const whereSelect_1 = __importDefault(require("./whereSelect"));
+exports.SelectFromV1 = void 0;
+const selectJoined_1 = __importStar(require("./selectJoined"));
+const whereSelect_1 = __importStar(require("./whereSelect"));
 class SelectFrom {
     constructor(aggregator) {
         this.joined = (joins) => new selectJoined_1.default(this._aggregator).apply(joins);
-        this.joined2 = (joins) => new selectJoined_1.default(this._aggregator).apply2(joins);
         this.limit = (limit) => {
             this._aggregator.limit(limit);
             return this;
@@ -33,3 +49,30 @@ class SelectFrom {
     }
 }
 exports.default = SelectFrom;
+class SelectFromV1 {
+    constructor(aggregator) {
+        this.joined = (joins) => new selectJoined_1.SelectJoinedV1(this._aggregator).apply(joins);
+        this.limit = (limit) => {
+            this._aggregator.limit(limit);
+            return this;
+        };
+        this.offset = (offset) => {
+            this._aggregator.offset(offset);
+            return this;
+        };
+        this.orderBy = (orderBy, order) => {
+            this._aggregator.orderBy(orderBy, order);
+            return this;
+        };
+        this.distinct = (column) => {
+            if (column) {
+                this._aggregator.distinct(column);
+            }
+            return this;
+        };
+        this.filteredBy = (filters) => new whereSelect_1.WhereSelectV1(this._aggregator).apply(filters);
+        this.build = () => this._aggregator.buildQuery();
+        this._aggregator = aggregator;
+    }
+}
+exports.SelectFromV1 = SelectFromV1;