drizzle-orm 0.9.12 → 0.9.16

package/README.md

@@ -0,0 +1,399 @@
+# DrizzleORM
+
+**DrizzleORM** is an ORM framework for 
+[TypeScript](https://www.typescriptlang.org/).
+It offers you several levels of Database communication:
+* Typesafe Table View approach 
+* Typesafe Query Builder
+* Simple SQL query execution
+
+Drizzle ORM is highly influenced by [Exposed](https://github.com/JetBrains/Exposed) and Jetbrains development methodology
+
+## Supported Databases
+
+* PostgreSQL
+
+## Links
+
+In Progress
+
+## Installing
+
+```bash
+npm install drizzle-orm drizzle-kit
+```
+#### **In Progress**
+```bash
+yarn add drizzle-orm drizzle-kit
+bower install drizzle-orm drizzle-kit
+```
+
+## Connecting to database
+
+```tsx
+import { DbConnector } from "drizzle-orm";
+
+// connect via postgresql connection url
+const db = await new DbConnector()
+	.connectionString("postgres://user:password@host:port/db")
+	.connect();
+
+// or by params
+const db = await new DbConnector()
+	.params({
+		host: '0.0.0.0',
+		port: 5432,
+		user: 'user',
+		password: 'password',
+		db: 'optional_db_name'
+	}).connect();
+```
+## Project structure
+- tables folder
+- migrations folder
+
+## Create tables
+### Users Table
+---
+```typescript
+
+export const rolesEnum = createEnum({ alias: 'test-enum', values: ['user', 'guest', 'admin'] });
+
+export default class UsersTable extends AbstractTable<UsersTable> {
+  public id = this.serial('id').primaryKey();
+  public fullName = this.text('full_name');
+
+  public phone = this.varchar('phone', { size: 256 });
+  public media = this.jsonb<string[]>('media');
+  public decimalField = this.decimal('test', { precision: 100, scale: 2 }).notNull();
+  public bigIntField = this.bigint('test1', 'max_bytes_53');
+  public role = this.type(rolesEnum, 'name_in_table').notNull();
+
+  public createdAt = this.timestamp('created_at').notNull();
+
+  public createdAtWithTimezone = this.timestamptz('created_at_time_zone');
+
+  public updatedAt = this.timestamp('updated_at').defaultValue(Defaults.CURRENT_TIMESTAMP);
+  public isArchived = this.bool('is_archived').defaultValue(false);
+
+  public phoneFullNameIndex = this.index([this.phone, this.fullName]);
+  public phoneIndex = this.uniqueIndex(this.phone);
+
+  public tableName(): string {
+    return 'users';
+  }
+}
+```
+### Cities Table
+---
+```typescript
+interface CityMeta {
+  population: number,
+  connection: string,
+}
+
+export default class CitiesTable extends AbstractTable<CitiesTable> {
+  public id = this.serial('id').primaryKey();
+
+  public foundationDate = this.timestamp('name').notNull();
+  public location = this.varchar('page', { size: 256 });
+
+  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onUpdate: 'CASCADE' });
+
+  public metadata = this.jsonb<CityMeta>('metadata');
+
+  public tableName(): string {
+    return 'cities';
+  }
+}
+```
+### User Groups Table
+---
+```typescript
+export default class UserGroupsTable extends AbstractTable<UserGroupsTable> {
+  public id = this.serial('id').primaryKey();
+
+  public name = this.varchar('name');
+  public description = this.varchar('description');
+
+  public tableName(): string {
+    return 'user_groups';
+  }
+}
+```
+### User to User Groups Table
+---
+#### Many to many connection between Users and User Groups
+```typescript
+export default class UsersToUserGroupsTable extends AbstractTable<UsersToUserGroupsTable> {
+  public groupId = this.int('city_id').foreignKey(UserGroupsTable, (table) => table.id, { onDelete: 'CASCADE' });
+  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onDelete: 'CASCADE' });
+
+  public manyToManyIndex = this.index([this.groupId, this.userId]);
+
+  public tableName(): string {
+    return 'users_to_user_groups';
+  }
+}
+```
+
+## CRUD
+### **SELECT**
+---
+```typescript
+const db = await new DbConnector()
+  .connectionString('postgresql://postgres@127.0.0.1/drizzle')
+  .connect();
+
+const usersTable = new UsersTable(db);
+
+// select all
+const allSelect = await usersTable.select().all();
+
+// select first
+const firstSelect = await usersTable.select().first();
+```
+#### **Sorting and Filtering**
+---
+##### Select all records from `Users` where phone is `"hello"`
+```typescript
+const eqSelect = await usersTable.select().where(
+  eq(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` where **both** phone is `"hello"` **and** phone is `"hello"`
+```typescript
+const andSelect = await usersTable.select().where(
+  and([
+    eq(usersTable.phone, 'hello'),
+    eq(usersTable.phone, 'hello')
+  ]),
+).all();
+```
+##### Select all records from `Users` where **either** phone is `"hello"` **or** phone is `"hello"`
+```typescript
+const orSelect = await usersTable.select().where(
+  or([eq(usersTable.phone, 'hello')]),
+).all();
+```
+##### Select all records from `Users` using **LIMIT** and **OFFSET**
+```typescript
+const limitOffsetSelect = await usersTable.select({ limit: 10, offset: 10 }).all();
+```
+##### Select all records from `Users` where `phone` contains `"hello"`
+```typescript
+const likeSelect = await usersTable.select().where(
+  like(usersTable.phone, '%hello%')
+).all();
+```
+##### Select all records from `Users` where `phone` equals to some of values from array
+```typescript
+const inArraySelect = usersTable.select().where(
+  inArray(usersTable.phone, ['hello'])
+).all();
+```
+##### Select all records from `Users` where `phone` greater(**>**) than `"hello"`
+```typescript
+const greaterSelect = usersTable.select().where(
+  greater(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` where `phone` less(**<**) than `"hello"`
+```typescript
+const lessSelect = usersTable.select().where(
+  less(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` where `phone` greater or equals(**>=**) than `"hello"`
+```typescript
+const greaterEqSelect = usersTable.select().where(
+  greaterEq(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` where `phone` less or equals(**<=**) 
+```typescript
+const lessEqSelect = usersTable.select().where(
+  lessEq(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` where `phone` is **NULL**
+```typescript
+const isNullSelect = usersTable.select().where(
+  isNull(usersTable.phone)
+).all();
+```
+##### Select all records from `Users` where `phone` not equals to `"hello"`
+```typescript
+const notEqSelect = usersTable.select().where(
+  notEq(usersTable.phone, 'hello')
+).all();
+```
+##### Select all records from `Users` ordered by `phone` in ascending order
+```typescript
+const ordered = await usersTable.select().orderBy((table) => table.phone, Order.ASC).all();
+```
+
+### **Update**
+---
+##### Update `fullName` to `newName` in `Users` where phone is `"hello"`
+```typescript
+await usersTable.update()
+  .where(eq(usersTable.phone, 'hello'))
+  .set({ fullName: 'newName' })
+  .execute();
+```
+##### Update `fullName` to `newName` in `Users` where phone is `"hello"` returning updated `User` model
+```typescript
+await usersTable.update()
+  .where(eq(usersTable.phone, 'hello'))
+  .set({ fullName: 'newName' })
+  .all();
+```
+##### Update `fullName` to `newName` in `Users` where phone is `"hello"` returning updated `User` model
+```typescript
+await usersTable.update()
+  .where(eq(usersTable.phone, 'hello'))
+  .set({ fullName: 'newName' })
+  .first();
+```
+
+### **Delete**
+##### Delete `user` where phone is `"hello"`
+```typescript
+await usersTable.delete()
+      .where(eq(usersTable.phone, 'hello'))
+      .execute();
+```
+##### Delete `user` where phone is `"hello"` returning updated `User` model
+```typescript
+await usersTable.delete()
+      .where(eq(usersTable.phone, 'hello'))
+      .all();
+```
+##### Delete `user` where phone is `"hello"` returning updated `User` model
+```typescript
+await usersTable.delete()
+      .where(eq(usersTable.phone, 'hello'))
+      .first();
+```
+
+### **Insert**
+##### Insert `user` with required fields
+```typescript
+await usersTable.insert({
+  test: 1,
+  createdAt: new Date(),
+}).execute();
+```
+##### Insert `user` with required fields and get all rows as array
+```typescript
+const user = await usersTable.insert({
+  test: 1,
+  createdAt: new Date(),
+}).all();
+```
+##### Insert `user` with required fields and get inserted entity
+```typescript
+const user = await usersTable.insert({
+  test: 1,
+  createdAt: new Date(),
+}).first();
+```
+##### Insert many `users` with required fields and get all inserted entities
+```typescript
+const users = await usersTable.insertMany([{
+      test: 1,
+      createdAt: new Date(),
+    }, {
+      test: 2,
+      createdAt: new Date(),
+    }]).all();
+```
+##### Insert many `users` with required fields and get all inserted entities. If such user already exists - update `phone` field
+```typescript
+await usersTable.insertMany([{
+      test: 1,
+      createdAt: new Date(),
+    }, {
+      test: 2,
+      createdAt: new Date(),
+    }])
+      .onConflict(
+        (table) => table.phoneIndex,
+        { phone: 'confilctUpdate' },
+      ).all();
+```
+
+## Joins
+### Join One-To-Many Tables
+##### Join Cities with Users and map to city object with full user
+```typescript
+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 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(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
+```typescript
+    const usersWithUserGroups = await usersToUserGroupsTable.select()
+      .where(eq(userGroupsTable.id, 1))
+      .leftJoin(UsersTable,
+        (userToGroup) => userToGroup.userId,
+        (users) => users.id)
+      .leftJoin(UserGroupsTable,
+        (userToGroup) => userToGroup.groupId,
+        (users) => users.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,
+    };
+```
+
+## Migrations
+#### To run migrations generated by drizzle-kit you could use `Migtator` class
+##### Provide drizzle-kit config path
+```typescript
+await drizzle.migrator(db).migrate('src/drizzle.config.yaml');
+```
+##### Provide object with path to folder with migrations
+```typescript
+await drizzle.migrator(db).migrate({ migrationFolder: 'drizzle' });
+```

package/builders/highLvlBuilders/abstractRequestBuilder.d.ts

@@ -1,18 +1,18 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
-import Session from '../../db/session';
+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>> {
     protected _table: TTable;
-    protected _session: Session;
+    protected _session: ISession;
     protected _mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     };
     protected _columns: AbstractColumn<ColumnType>[];
     protected _logger?: BaseLogger;
-    constructor(table: AbstractTable<TTable>, session: Session, mappedServiceToDb: {
+    constructor(table: AbstractTable<TTable>, session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, logger?: BaseLogger);
     all: () => Promise<Array<ExtractModel<TTable> | undefined>>;

package/builders/highLvlBuilders/deleteRequestBuilder.d.ts

@@ -1,6 +1,6 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
-import Session from '../../db/session';
+import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel } from '../../tables/inferTypes';
@@ -8,7 +8,7 @@ import Expr from '../requestBuilders/where/where';
 import TableRequestBuilder from './abstractRequestBuilder';
 export default class DeleteTRB<TTable extends AbstractTable<TTable>> extends TableRequestBuilder<TTable> {
     private _filter;
-    constructor(table: AbstractTable<TTable>, session: Session, mappedServiceToDb: {
+    constructor(table: AbstractTable<TTable>, session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, logger?: BaseLogger);
     where: (expr: Expr) => DeleteTRB<TTable>;

package/builders/highLvlBuilders/deleteRequestBuilder.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const builderError_1 = require("../../errors/builderError");
-const dbErrors_1 = require("../../errors/dbErrors");
 const responseMapper_1 = require("../../mappers/responseMapper");
 const delete_1 = require("../lowLvlBuilders/delets/delete");
 const abstractRequestBuilder_1 = require("./abstractRequestBuilder");
@@ -30,13 +29,7 @@ class DeleteTRB extends abstractRequestBuilder_1.default {
                 this._logger.info(`Deleting from ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseDeleteError(this._table.tableName(), reason, query);
-            }
-            else {
-                return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
-            }
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
     }
 }

package/builders/highLvlBuilders/insertRequestBuilder.d.ts

@@ -1,6 +1,6 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
-import Session from '../../db/session';
+import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel, Indexing } from '../../tables/inferTypes';
@@ -9,7 +9,7 @@ export default class InsertTRB<TTable extends AbstractTable<TTable>> extends Tab
     private _values;
     private _onConflict;
     private _onConflictField;
-    constructor(values: ExtractModel<TTable>[], session: Session, mappedServiceToDb: {
+    constructor(values: ExtractModel<TTable>[], session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, table: AbstractTable<TTable>, logger?: BaseLogger);
     execute: () => Promise<void>;

package/builders/highLvlBuilders/insertRequestBuilder.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const __1 = require("..");
 const builderError_1 = require("../../errors/builderError");
-const dbErrors_1 = require("../../errors/dbErrors");
 const responseMapper_1 = require("../../mappers/responseMapper");
 const insert_1 = require("../lowLvlBuilders/inserts/insert");
 const abstractRequestBuilder_1 = require("./abstractRequestBuilder");
@@ -40,13 +39,7 @@ class InsertTRB extends abstractRequestBuilder_1.default {
                 this._logger.info(`Inserting to ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseInsertError(this._table.tableName(), reason, query);
-            }
-            else {
-                return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
-            }
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
         this._values = values;
     }

package/builders/highLvlBuilders/selectRequestBuilder.d.ts

@@ -1,7 +1,7 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
 import DB from '../../db/db';
-import Session from '../../db/session';
+import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel } from '../../tables/inferTypes';
@@ -16,7 +16,7 @@ export default class SelectTRB<TTable extends AbstractTable<TTable>> extends Tab
     private __groupBy?;
     private __order?;
     private __distinct;
-    constructor(session: Session, mappedServiceToDb: {
+    constructor(session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, props: {
         limit?: number;

package/builders/highLvlBuilders/selectRequestBuilder.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable import/no-cycle */
 const __1 = require("..");
 const builderError_1 = require("../../errors/builderError");
-const dbErrors_1 = require("../../errors/dbErrors");
 const responseMapper_1 = require("../../mappers/responseMapper");
 const selectWithJoin_1 = require("../joinBuilders/builders/selectWithJoin");
 const join_1 = require("../joinBuilders/join");
@@ -43,13 +42,7 @@ class SelectTRB extends abstractRequestBuilder_1.default {
                 this._logger.info(`Selecting from ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseSelectError(this._table.tableName(), reason, query);
-            }
-            else {
-                return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
-            }
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
         this.props = props;
     }

package/builders/highLvlBuilders/updateRequestBuilder.d.ts

@@ -1,6 +1,6 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
-import Session from '../../db/session';
+import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel, ExtractUpdateModel } from '../../tables/inferTypes';
@@ -10,7 +10,7 @@ export default class UpdateTRB<TTable extends AbstractTable<TTable>> extends Tab
     private _filter;
     private _update;
     private _objToUpdate;
-    constructor(table: AbstractTable<TTable>, session: Session, mappedServiceToDb: {
+    constructor(table: AbstractTable<TTable>, session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, logger?: BaseLogger);
     where: (expr: Expr) => UpdateTRB<TTable>;

package/builders/highLvlBuilders/updateRequestBuilder.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const builderError_1 = require("../../errors/builderError");
-const dbErrors_1 = require("../../errors/dbErrors");
 const responseMapper_1 = require("../../mappers/responseMapper");
 const update_1 = require("../lowLvlBuilders/updates/update");
 const static_1 = require("../requestBuilders/updates/static");
@@ -48,13 +47,7 @@ class UpdateTRB extends abstractRequestBuilder_1.default {
                 this._logger.info(`Updating ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseUpdateError(this._table.tableName(), reason, query);
-            }
-            else {
-                return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
-            }
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
     }
 }

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

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

package/builders/joinBuilders/builders/abstractJoinBuilder.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const builderError_1 = require("../../../errors/builderError");
-const dbErrors_1 = require("../../../errors/dbErrors");
 const select_1 = require("../../lowLvlBuilders/selects/select");
 class AbstractJoined {
     constructor(table, filter, session, props, orderBy, order, distinct) {
@@ -22,13 +21,7 @@ class AbstractJoined {
                 throw new builderError_1.default(builderError_1.BuilderType.JOINED_SELECT, this._table.tableName(), Object.values(this._table.mapServiceToDb()), e, this._filter);
             }
             const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseSelectError(this._table.tableName(), reason, query);
-            }
-            else {
-                return this.mapResponse(result.value);
-            }
+            return this.mapResponse(result);
         };
         this._table = table;
         this._session = session;

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

@@ -1,7 +1,7 @@
 import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
-import Session from '../../../db/session';
+import { ISession } from '../../../db/session';
 import { AbstractTable } from '../../../tables';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
@@ -14,7 +14,7 @@ export default class SelectTRBWithFiveJoins<TTable extends AbstractTable<TTable>
     private _join3;
     private _join4;
     private _join5;
-    constructor(table: TTable, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, join5: Join<TTable5>, props: {
+    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>);

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

@@ -2,7 +2,7 @@ import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import DB from '../../../db/db';
-import Session from '../../../db/session';
+import { ISession } from '../../../db/session';
 import { AbstractTable } from '../../../tables';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
@@ -15,7 +15,7 @@ export default class SelectTRBWithFourJoins<TTable extends AbstractTable<TTable>
     private _join2;
     private _join3;
     private _join4;
-    constructor(table: TTable, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, props: {
+    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>);