drizzle-orm 0.10.43 → 0.10.44

package/README.md

@@ -0,0 +1,439 @@
+# 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().findOne();
+```
+#### **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();
+```
+#### **Partial Selecting**
+ ```typescript
+    const partialSelect = await usersTable.select({
+      mappedId: usersTable.id,
+      mappedPhone: usersTable.phone,
+    }).all();
+
+    // Usage
+    const { mappedId, mappedPhone } = partialSelect;
+ ```
+
+
+### **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' })
+  .findOne();
+```
+
+### **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'))
+      .findOne();
+```
+
+### **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(),
+}).findOne();
+```
+##### 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(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
+```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) => 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({
+      id: citiesTable.id,
+      userId: citiesTable.userId,
+    })
+    .where(eq(citiesTable.id, 1))
+    .leftJoin(UsersTable,
+        (city) => city.userId,
+        (users) => users.id,
+        {
+          id: usersTable.id,
+        })
+    .execute();
+
+const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
+```
+
+
+## Migrations
+#### To run migrations generated by drizzle-kit you could use `Migrator` class
+##### Provide drizzle-kit config path
+```typescript
+await drizzle.migrator(db).migrate('src/drizzle.config.yaml');
+```
+##### Another possibility is to provide object with path to folder with migrations
+```typescript
+await drizzle.migrator(db).migrate({ migrationFolder: 'drizzle' });
+```
+
+
+## Raw query usage
+#### If you have some complex queries to execute and drizzle-orm can't handle them yet, then you could use `rawQuery` execution
+
+
+##### Execute custom raw query
+```typescript
+const res: QueryResult<any> = await db.session().execute('SELECT * FROM users WHERE user.id = $1', [1]);
+```

package/builders/highLvlBuilders/selectRequestBuilder.js

@@ -99,7 +99,7 @@ class SelectTRB extends abstractRequestBuilder_1.default {
         const toColumn = to(toTable);
         const join = new __1.JoinWith(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.INNER_JOIN);
-        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct, this.__partial, partial);
+        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) {
         const toTable = this._table.db.create(table);
@@ -107,7 +107,7 @@ class SelectTRB extends abstractRequestBuilder_1.default {
         const toColumn = to(toTable);
         const join = new __1.JoinWith(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.LEFT_JOIN);
-        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct, this.__partial, partial);
+        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) {
         const toTable = this._table.db.create(table);
@@ -115,7 +115,7 @@ class SelectTRB extends abstractRequestBuilder_1.default {
         const toColumn = to(toTable);
         const join = new __1.JoinWith(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.RIGHT_JOIN);
-        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct, this.__partial, partial);
+        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) {
         const toTable = this._table.db.create(table);
@@ -123,7 +123,7 @@ class SelectTRB extends abstractRequestBuilder_1.default {
         const toColumn = to(toTable);
         const join = new __1.JoinWith(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.FULL_JOIN);
-        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct, this.__partial, partial);
+        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);
     }
 }
 exports.default = SelectTRB;

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

@@ -1,3 +1,4 @@
+import BaseLogger from 'orm/src/logger/abstractLogger';
 import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
@@ -19,10 +20,11 @@ export default abstract class AbstractJoined<TTable extends AbstractTable<TTable
     protected _orderBy?: AbstractColumn<ColumnType, boolean, boolean>;
     protected _order?: Order;
     protected _partial?: TPartial;
+    protected _logger?: BaseLogger;
     constructor(table: TTable, filter: Expr, session: ISession, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial);
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, logger?: BaseLogger);
     limit: (limit: number) => this;
     offset: (offset: number) => this;
     execute: () => Promise<TRes>;

package/builders/joinBuilders/builders/abstractJoinBuilder.js

@@ -26,7 +26,7 @@ const builderError_1 = __importStar(require("../../../errors/builderError"));
 const responseMapper_1 = __importDefault(require("../../../mappers/responseMapper"));
 const select_1 = __importDefault(require("../../lowLvlBuilders/selects/select"));
 class AbstractJoined {
-    constructor(table, filter, session, props, orderBy, order, distinct, tablePartial) {
+    constructor(table, filter, session, props, orderBy, order, distinct, tablePartial, logger) {
         this.limit = (limit) => {
             this._props.limit = limit;
             return this;
@@ -54,6 +54,10 @@ class AbstractJoined {
             catch (e) {
                 throw new builderError_1.default(builderError_1.BuilderType.JOINED_SELECT, this._table.tableName(), Object.values(this._table.mapServiceToDb()), e, this._session, this._filter);
             }
+            if (this._logger) {
+                this._logger.info(`Selecting from ${this._table.tableName()} using query:\n ${query}`);
+                this._logger.info(`Values for query:\n ${values}`);
+            }
             const result = await this._session.execute(query, values);
             return this.mapResponse(result);
         };
@@ -65,6 +69,7 @@ class AbstractJoined {
         this._orderBy = orderBy;
         this._distinct = distinct;
         this._partial = tablePartial;
+        this._logger = logger;
     }
     fullOrPartial(mappedServiceToDb, result, partial, joinId) {
         if (partial) {

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

@@ -1,3 +1,4 @@
+import BaseLogger from 'orm/src/logger/abstractLogger';
 import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
@@ -23,7 +24,7 @@ export default class SelectTRBWithFiveJoins<TTable extends AbstractTable<TTable>
     constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, join5: Join<TTable5>, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3, joinedPartial3?: TPartial4, joinedPartial4?: TPartial5);
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3, joinedPartial3?: TPartial4, joinedPartial4?: TPartial5, logger?: BaseLogger);
     protected joins(): Array<{
         join: Join<any>;
         partial?: {

package/builders/joinBuilders/builders/selectWithFiveJoins.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const selectResponseFiveJoins_1 = __importDefault(require("../responses/selectResponseFiveJoins"));
 const abstractJoinBuilder_1 = __importDefault(require("./abstractJoinBuilder"));
 class SelectTRBWithFiveJoins extends abstractJoinBuilder_1.default {
-    constructor(table, session, filter, join1, join2, join3, join4, join5, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1, joinedPartial2, joinedPartial3, joinedPartial4) {
-        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
+    constructor(table, session, filter, join1, join2, join3, join4, join5, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1, joinedPartial2, joinedPartial3, joinedPartial4, logger) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial, logger);
         this._join1 = join1;
         this._join2 = join2;
         this._join3 = join3;

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

@@ -1,3 +1,4 @@
+import BaseLogger from 'orm/src/logger/abstractLogger';
 import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
@@ -23,7 +24,7 @@ export default class SelectTRBWithFourJoins<TTable extends AbstractTable<TTable>
     constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3, joinedPartial3?: TPartial4);
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3, joinedPartial3?: TPartial4, logger?: BaseLogger);
     innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
         new (db: DB): InputTable;
     }, table: {

package/builders/joinBuilders/builders/selectWithFourJoins.js

@@ -9,8 +9,8 @@ const selectResponseFourJoins_1 = __importDefault(require("../responses/selectRe
 const abstractJoinBuilder_1 = __importDefault(require("./abstractJoinBuilder"));
 const selectWithFiveJoins_1 = __importDefault(require("./selectWithFiveJoins"));
 class SelectTRBWithFourJoins extends abstractJoinBuilder_1.default {
-    constructor(table, session, filter, join1, join2, join3, join4, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1, joinedPartial2, joinedPartial3) {
-        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
+    constructor(table, session, filter, join1, join2, join3, join4, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1, joinedPartial2, joinedPartial3, logger) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial, logger);
         this._join1 = join1;
         this._join2 = join2;
         this._join3 = join3;
@@ -27,7 +27,7 @@ class SelectTRBWithFourJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.INNER_JOIN);
-        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial, this._logger);
     }
     leftJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -36,7 +36,7 @@ class SelectTRBWithFourJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.LEFT_JOIN);
-        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial, this._logger);
     }
     rightJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -45,7 +45,7 @@ class SelectTRBWithFourJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.RIGHT_JOIN);
-        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial, this._logger);
     }
     fullJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -54,7 +54,7 @@ class SelectTRBWithFourJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.FULL_JOIN);
-        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, this._joinedPartial3, partial, this._logger);
     }
     joins() {
         return [{ join: this._join1, partial: this._joinedPartial, id: 1 },

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

@@ -1,3 +1,4 @@
+import BaseLogger from 'orm/src/logger/abstractLogger';
 import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
@@ -17,7 +18,7 @@ export default class SelectTRBWithJoin<TTable extends AbstractTable<TTable>, TTa
     constructor(table: TTable, session: ISession, filter: Expr, join: Join<TTable1>, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1);
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, logger?: BaseLogger);
     innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
         new (db: DB): InputTable;
     }, table: {

package/builders/joinBuilders/builders/selectWithJoin.js

@@ -10,8 +10,8 @@ const abstractJoinBuilder_1 = __importDefault(require("./abstractJoinBuilder"));
 const selectWithTwoJoins_1 = __importDefault(require("./selectWithTwoJoins"));
 // eslint-disable-next-line max-len
 class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
-    constructor(table, session, filter, join, props, orderBy, order, distinct, tablePartial, joinedPartial) {
-        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
+    constructor(table, session, filter, join, props, orderBy, order, distinct, tablePartial, joinedPartial, logger) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial, logger);
         this._join = join;
         this._joinedPartial = joinedPartial;
     }
@@ -22,7 +22,7 @@ class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.INNER_JOIN);
-        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial, this._logger);
     }
     leftJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -31,7 +31,7 @@ class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.LEFT_JOIN);
-        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial, this._logger);
     }
     rightJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -40,7 +40,7 @@ class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.RIGHT_JOIN);
-        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial, this._logger);
     }
     fullJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -49,7 +49,7 @@ class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.FULL_JOIN);
-        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, partial, this._logger);
     }
     joins() {
         return [{ join: this._join, partial: this._joinedPartial, id: 1 }];

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

@@ -1,3 +1,4 @@
+import BaseLogger from 'orm/src/logger/abstractLogger';
 import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
@@ -21,7 +22,7 @@ export default class SelectTRBWithThreeJoins<TTable extends AbstractTable<TTable
     constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3);
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, joinedPartial2?: TPartial3, logger?: BaseLogger);
     innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
         new (db: DB): InputTable;
     }, table: {

package/builders/joinBuilders/builders/selectWithThreeJoins.js

@@ -9,8 +9,8 @@ const selectResponseThreeJoins_1 = __importDefault(require("../responses/selectR
 const abstractJoinBuilder_1 = __importDefault(require("./abstractJoinBuilder"));
 const selectWithFourJoins_1 = __importDefault(require("./selectWithFourJoins"));
 class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
-    constructor(table, session, filter, join1, join2, join3, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1, joinedPartial2) {
-        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
+    constructor(table, session, filter, join1, join2, join3, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1, joinedPartial2, logger) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial, logger);
         this._join1 = join1;
         this._join2 = join2;
         this._join3 = join3;
@@ -25,7 +25,7 @@ class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.INNER_JOIN);
-        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial, this._logger);
     }
     leftJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -34,7 +34,7 @@ class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.LEFT_JOIN);
-        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial, this._logger);
     }
     rightJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -43,7 +43,7 @@ class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.RIGHT_JOIN);
-        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial, this._logger);
     }
     fullJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -52,7 +52,7 @@ class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.FULL_JOIN);
-        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, this._joinedPartial2, partial, this._logger);
     }
     mapResponse(result) {
         const parent = this._join1.mappedServiceToDb;

package/builders/joinBuilders/builders/selectWithTwoJoins.d.ts

@@ -1,3 +1,4 @@
+import BaseLogger from 'orm/src/logger/abstractLogger';
 import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
@@ -19,7 +20,7 @@ export default class SelectTRBWithTwoJoins<TTable extends AbstractTable<TTable>,
     constructor(table: TTable, session: ISession, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2);
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2, logger?: BaseLogger);
     innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, TToColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
         new (db: DB): InputTable;
     }, table: {

package/builders/joinBuilders/builders/selectWithTwoJoins.js

@@ -9,8 +9,8 @@ const selectResponseTwoJoins_1 = __importDefault(require("../responses/selectRes
 const abstractJoinBuilder_1 = __importDefault(require("./abstractJoinBuilder"));
 const selectWithThreeJoins_1 = __importDefault(require("./selectWithThreeJoins"));
 class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
-    constructor(table, session, filter, join1, join2, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1) {
-        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
+    constructor(table, session, filter, join1, join2, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1, logger) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial, logger);
         this._join1 = join1;
         this._join2 = join2;
         this._joinedPartial = joinedPartial;
@@ -23,7 +23,7 @@ class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.INNER_JOIN);
-        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial, this._logger);
     }
     leftJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -32,7 +32,7 @@ class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.LEFT_JOIN);
-        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial, this._logger);
     }
     rightJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -41,7 +41,7 @@ class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.RIGHT_JOIN);
-        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial, this._logger);
     }
     fullJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
@@ -50,7 +50,7 @@ class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
         const toColumn = to(toTable);
         const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
             .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.FULL_JOIN);
-        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial, this._logger);
     }
     mapResponse(result) {
         const parent = this._join1.mappedServiceToDb;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-orm",
-  "version": "0.10.43",
+  "version": "0.10.44",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,5 +34,6 @@
     "ts": "tsc",
     "lint": "eslint ./src --ext .ts",
     "run": "ts-node src/tables/newAbstractTable.ts"
-  }
+  },
+  "readme": "# DrizzleORM\n\n**DrizzleORM** is an ORM framework for \n[TypeScript](https://www.typescriptlang.org/).\nIt offers you several levels of Database communication:\n* Typesafe Table View approach \n* Typesafe Query Builder\n* Simple SQL query execution\n\nDrizzle ORM is highly influenced by [Exposed](https://github.com/JetBrains/Exposed) and Jetbrains development methodology\n\n## Supported Databases\n\n* PostgreSQL\n\n## Links\n\nIn Progress\n\n## Installing\n\n```bash\nnpm install drizzle-orm drizzle-kit\n```\n#### **In Progress**\n```bash\nyarn add drizzle-orm drizzle-kit\nbower install drizzle-orm drizzle-kit\n```\n\n## Connecting to database\n\n```tsx\nimport { DbConnector } from \"drizzle-orm\";\n\n// connect via postgresql connection url\nconst db = await new DbConnector()\n\t.connectionString(\"postgres://user:password@host:port/db\")\n\t.connect();\n\n// or by params\nconst db = await new DbConnector()\n\t.params({\n\t\thost: '0.0.0.0',\n\t\tport: 5432,\n\t\tuser: 'user',\n\t\tpassword: 'password',\n\t\tdb: 'optional_db_name'\n\t}).connect();\n```\n## Project structure\n- tables folder\n- migrations folder\n\n## Create tables\n### Users Table\n---\n```typescript\n\nexport const rolesEnum = createEnum({ alias: 'test-enum', values: ['user', 'guest', 'admin'] });\n\nexport default class UsersTable extends AbstractTable<UsersTable> {\n  public id = this.serial('id').primaryKey();\n  public fullName = this.text('full_name');\n\n  public phone = this.varchar('phone', { size: 256 });\n  public media = this.jsonb<string[]>('media');\n  public decimalField = this.decimal('test', { precision: 100, scale: 2 }).notNull();\n  public bigIntField = this.bigint('test1', 'max_bytes_53');\n  public role = this.type(rolesEnum, 'name_in_table').notNull();\n\n  public createdAt = this.timestamp('created_at').notNull();\n\n  public createdAtWithTimezone = this.timestamptz('created_at_time_zone');\n\n  public updatedAt = this.timestamp('updated_at').defaultValue(Defaults.CURRENT_TIMESTAMP);\n  public isArchived = this.bool('is_archived').defaultValue(false);\n\n  public phoneFullNameIndex = this.index([this.phone, this.fullName]);\n  public phoneIndex = this.uniqueIndex(this.phone);\n\n  public tableName(): string {\n    return 'users';\n  }\n}\n```\n### Cities Table\n---\n```typescript\ninterface CityMeta {\n  population: number,\n  connection: string,\n}\n\nexport default class CitiesTable extends AbstractTable<CitiesTable> {\n  public id = this.serial('id').primaryKey();\n\n  public foundationDate = this.timestamp('name').notNull();\n  public location = this.varchar('page', { size: 256 });\n\n  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onUpdate: 'CASCADE' });\n\n  public metadata = this.jsonb<CityMeta>('metadata');\n\n  public tableName(): string {\n    return 'cities';\n  }\n}\n```\n### User Groups Table\n---\n```typescript\nexport default class UserGroupsTable extends AbstractTable<UserGroupsTable> {\n  public id = this.serial('id').primaryKey();\n\n  public name = this.varchar('name');\n  public description = this.varchar('description');\n\n  public tableName(): string {\n    return 'user_groups';\n  }\n}\n```\n### User to User Groups Table\n---\n#### Many to many connection between Users and User Groups\n```typescript\nexport default class UsersToUserGroupsTable extends AbstractTable<UsersToUserGroupsTable> {\n  public groupId = this.int('city_id').foreignKey(UserGroupsTable, (table) => table.id, { onDelete: 'CASCADE' });\n  public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onDelete: 'CASCADE' });\n\n  public manyToManyIndex = this.index([this.groupId, this.userId]);\n\n  public tableName(): string {\n    return 'users_to_user_groups';\n  }\n}\n```\n\n## CRUD\n### **SELECT**\n---\n```typescript\nconst db = await new DbConnector()\n  .connectionString('postgresql://postgres@127.0.0.1/drizzle')\n  .connect();\n\nconst usersTable = new UsersTable(db);\n\n// select all\nconst allSelect = await usersTable.select().all();\n\n// select first\nconst firstSelect = await usersTable.select().findOne();\n```\n#### **Sorting and Filtering**\n---\n##### Select all records from `Users` where phone is `\"hello\"`\n```typescript\nconst eqSelect = await usersTable.select().where(\n  eq(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` where **both** phone is `\"hello\"` **and** phone is `\"hello\"`\n```typescript\nconst andSelect = await usersTable.select().where(\n  and([\n    eq(usersTable.phone, 'hello'),\n    eq(usersTable.phone, 'hello')\n  ]),\n).all();\n```\n##### Select all records from `Users` where **either** phone is `\"hello\"` **or** phone is `\"hello\"`\n```typescript\nconst orSelect = await usersTable.select().where(\n  or([eq(usersTable.phone, 'hello')]),\n).all();\n```\n##### Select all records from `Users` using **LIMIT** and **OFFSET**\n```typescript\nconst limitOffsetSelect = await usersTable.select().limit(10).offset(10).all();\n```\n##### Select all records from `Users` where `phone` contains `\"hello\"`\n```typescript\nconst likeSelect = await usersTable.select().where(\n  like(usersTable.phone, '%hello%')\n).all();\n```\n##### Select all records from `Users` where `phone` equals to some of values from array\n```typescript\nconst inArraySelect = usersTable.select().where(\n  inArray(usersTable.phone, ['hello'])\n).all();\n```\n##### Select all records from `Users` where `phone` greater(**>**) than `\"hello\"`\n```typescript\nconst greaterSelect = usersTable.select().where(\n  greater(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` where `phone` less(**<**) than `\"hello\"`\n```typescript\nconst lessSelect = usersTable.select().where(\n  less(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` where `phone` greater or equals(**>=**) than `\"hello\"`\n```typescript\nconst greaterEqSelect = usersTable.select().where(\n  greaterEq(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` where `phone` less or equals(**<=**) \n```typescript\nconst lessEqSelect = usersTable.select().where(\n  lessEq(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` where `phone` is **NULL**\n```typescript\nconst isNullSelect = usersTable.select().where(\n  isNull(usersTable.phone)\n).all();\n```\n##### Select all records from `Users` where `phone` not equals to `\"hello\"`\n```typescript\nconst notEqSelect = usersTable.select().where(\n  notEq(usersTable.phone, 'hello')\n).all();\n```\n##### Select all records from `Users` ordered by `phone` in ascending order\n```typescript\nconst ordered = await usersTable.select().orderBy((table) => table.phone, Order.ASC).all();\n```\n#### **Partial Selecting**\n ```typescript\n    const partialSelect = await usersTable.select({\n      mappedId: usersTable.id,\n      mappedPhone: usersTable.phone,\n    }).all();\n\n    // Usage\n    const { mappedId, mappedPhone } = partialSelect;\n ```\n\n\n### **Update**\n---\n##### Update `fullName` to `newName` in `Users` where phone is `\"hello\"`\n```typescript\nawait usersTable.update()\n  .where(eq(usersTable.phone, 'hello'))\n  .set({ fullName: 'newName' })\n  .execute();\n```\n##### Update `fullName` to `newName` in `Users` where phone is `\"hello\"` returning updated `User` model\n```typescript\nawait usersTable.update()\n  .where(eq(usersTable.phone, 'hello'))\n  .set({ fullName: 'newName' })\n  .all();\n```\n##### Update `fullName` to `newName` in `Users` where phone is `\"hello\"` returning updated `User` model\n```typescript\nawait usersTable.update()\n  .where(eq(usersTable.phone, 'hello'))\n  .set({ fullName: 'newName' })\n  .findOne();\n```\n\n### **Delete**\n##### Delete `user` where phone is `\"hello\"`\n```typescript\nawait usersTable.delete()\n      .where(eq(usersTable.phone, 'hello'))\n      .execute();\n```\n##### Delete `user` where phone is `\"hello\"` returning updated `User` model\n```typescript\nawait usersTable.delete()\n      .where(eq(usersTable.phone, 'hello'))\n      .all();\n```\n##### Delete `user` where phone is `\"hello\"` returning updated `User` model\n```typescript\nawait usersTable.delete()\n      .where(eq(usersTable.phone, 'hello'))\n      .findOne();\n```\n\n### **Insert**\n##### Insert `user` with required fields\n```typescript\nawait usersTable.insert({\n  test: 1,\n  createdAt: new Date(),\n}).execute();\n```\n##### Insert `user` with required fields and get all rows as array\n```typescript\nconst user = await usersTable.insert({\n  test: 1,\n  createdAt: new Date(),\n}).all();\n```\n##### Insert `user` with required fields and get inserted entity\n```typescript\nconst user = await usersTable.insert({\n  test: 1,\n  createdAt: new Date(),\n}).findOne();\n```\n##### Insert many `users` with required fields and get all inserted entities\n```typescript\nconst users = await usersTable.insertMany([{\n      test: 1,\n      createdAt: new Date(),\n    }, {\n      test: 2,\n      createdAt: new Date(),\n    }]).all();\n```\n##### Insert many `users` with required fields and get all inserted entities. If such user already exists - update `phone` field\n```typescript\nawait usersTable.insertMany([{\n      test: 1,\n      createdAt: new Date(),\n    }, {\n      test: 2,\n      createdAt: new Date(),\n    }])\n      .onConflict(\n        (table) => table.phoneIndex,\n        { phone: 'confilctUpdate' },\n      ).all();\n```\n\n## Joins\n### Join One-To-Many Tables\n##### Join Cities with Users and map to city object with full user\n```typescript\nconst usersTable = new UsersTable(db);\nconst citiesTable = new CitiesTable(db);\n\n const userWithCities = await citiesTable.select()\n      .where(eq(citiesTable.id, 1))\n      .leftJoin(UsersTable,\n        (city) => city.userId,\n        (users) => users.id)\n      .execute();\n\nconst citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));\n```\n\n### Join Many-To-Many Tables\n##### Join User Groups with Users, using many-to-many table and map response to get user object with groups array\n```typescript\n    const usersWithUserGroups = await usersToUserGroupsTable.select()\n      .where(eq(userGroupsTable.id, 1))\n      .leftJoin(UsersTable,\n        (userToGroup) => userToGroup.userId,\n        (users) => users.id)\n      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,\n        (userToGroup) => userToGroup.groupId,\n        (users) => users.id)\n      .execute();\n\n    const userGroupWithUsers = usersWithUserGroups.group({\n      one: (_, dbUser, dbUserGroup) => dbUser!,\n      many: (_, dbUser, dbUserGroup) => dbUserGroup!,\n    });\n\n    const userWithGroups: ExtractModel<UsersTable> & { groups: ExtractModel<UserGroupsTable>[] } = {\n      ...userGroupWithUsers.one,\n      groups: userGroupWithUsers.many,\n    };\n```\n##### Join User Groups with Users, using many-to-many table and map response to get user group object with users array\n```typescript\n    const usersWithUserGroups = await usersToUserGroupsTable.select()\n      .where(eq(userGroupsTable.id, 1))\n      .leftJoin(UsersTable,\n        (userToGroup) => userToGroup.userId,\n        (users) => users.id)\n      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,\n        (userToGroup) => userToGroup.groupId,\n        (users) => users.id)\n      .execute();\n\n    const userGroupWithUsers = usersWithUserGroups.group({\n      one: (_, dbUser, dbUserGroup) => dbUserGroup!,\n      many: (_, dbUser, dbUserGroup) => dbUser!,\n    });\n\n    const userWithGroups: ExtractModel<UserGroupsTable> & { users: ExtractModel<UsersTable>[] } = {\n      ...userGroupWithUsers.one,\n      users: userGroupWithUsers.many,\n    };\n```\n### Join using partial field select\n##### Join Cities with Users getting only needed fields form request\n```typescript\nawait citiesTable.select({\n      id: citiesTable.id,\n      userId: citiesTable.userId,\n    })\n    .where(eq(citiesTable.id, 1))\n    .leftJoin(UsersTable,\n        (city) => city.userId,\n        (users) => users.id,\n        {\n          id: usersTable.id,\n        })\n    .execute();\n\nconst citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));\n```\n\n\n## Migrations\n#### To run migrations generated by drizzle-kit you could use `Migrator` class\n##### Provide drizzle-kit config path\n```typescript\nawait drizzle.migrator(db).migrate('src/drizzle.config.yaml');\n```\n##### Another possibility is to provide object with path to folder with migrations\n```typescript\nawait drizzle.migrator(db).migrate({ migrationFolder: 'drizzle' });\n```\n\n\n## Raw query usage\n#### If you have some complex queries to execute and drizzle-orm can't handle them yet, then you could use `rawQuery` execution\n\n\n##### Execute custom raw query\n```typescript\nconst res: QueryResult<any> = await db.session().execute('SELECT * FROM users WHERE user.id = $1', [1]);\n```"
 }