drizzle-orm 0.10.24 → 0.10.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-orm",
-  "version": "0.10.24",
+  "version": "0.10.25",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -39,6 +39,5 @@
     "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```"
+  }
 }

package/README.md

@@ -1,439 +0,0 @@
-# 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/dist/builders/aggregators/abstractAggregator.d.ts

@@ -1,11 +0,0 @@
-import { AbstractColumn } from '../../columns/column';
-import ColumnType from '../../columns/types/columnType';
-import { AbstractTable } from '../../tables';
-export default class Aggregator {
-    protected _fields: Array<string>;
-    protected _table: AbstractTable<any>;
-    constructor(table: AbstractTable<any>, partial?: {
-        [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>;
-    });
-    protected generateSelectArray: (table: string, columns: AbstractColumn<ColumnType>[], id?: number | undefined) => string[];
-}

package/dist/builders/aggregators/abstractAggregator.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable max-len */
-const column_1 = require("../../columns/column");
-const ecranate_1 = require("../../utils/ecranate");
-// eslint-disable-next-line max-len
-class Aggregator {
-    constructor(table, partial) {
-        this._fields = [];
-        this.generateSelectArray = (table, columns, id) => {
-            const selectFields = [];
-            columns.forEach((field) => {
-                if (field instanceof column_1.Column) {
-                    selectFields.push(' ');
-                    selectFields.push(table);
-                    selectFields.push('.');
-                    selectFields.push(ecranate_1.ecranate(field.getColumnName()));
-                    selectFields.push(' AS ');
-                    selectFields.push(ecranate_1.ecranate(`${field.getAlias()}${id ? `_${id}` : ''}`));
-                    selectFields.push(',');
-                }
-            });
-            selectFields.pop();
-            return selectFields;
-        };
-        this._table = table;
-        if (!partial) {
-            this._fields = this.generateSelectArray(this._table.tableName(), Object.values(this._table.mapServiceToDb()));
-        }
-        else {
-            this._fields = this.generateSelectArray(this._table.tableName(), Object.values(partial));
-        }
-    }
-}
-exports.default = Aggregator;

package/dist/builders/aggregators/deleteAggregator.d.ts

@@ -1,16 +0,0 @@
-import { AbstractTable } from '../../tables';
-import Expr from '../requestBuilders/where/where';
-import Aggregator from './abstractAggregator';
-export default class DeleteAggregator extends Aggregator {
-    private _from;
-    private _filters;
-    private _values;
-    private _delete;
-    constructor(table: AbstractTable<any>);
-    filters: (filters: Expr) => DeleteAggregator;
-    appendFrom: (tableName: string) => DeleteAggregator;
-    buildQuery: () => {
-        query: string;
-        values: Array<any>;
-    };
-}

package/dist/builders/aggregators/deleteAggregator.js

@@ -1,42 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const abstractAggregator_1 = __importDefault(require("./abstractAggregator"));
-class DeleteAggregator extends abstractAggregator_1.default {
-    constructor(table) {
-        super(table);
-        this._from = [];
-        this._filters = [];
-        this._values = [];
-        this._delete = ['DELETE'];
-        this.filters = (filters) => {
-            if (filters) {
-                const filterQuery = filters.toQuery();
-                this._filters.push('WHERE ');
-                this._filters.push(filterQuery.query);
-                this._values = filterQuery.values;
-            }
-            return this;
-        };
-        this.appendFrom = (tableName) => {
-            this._from.push(' FROM ');
-            this._from.push(tableName);
-            return this;
-        };
-        this.buildQuery = () => {
-            // this._delete.push(this._fields.join(''));
-            this._delete.push('\n');
-            this._delete.push(this._from.join(''));
-            this._delete.push('\n');
-            this._delete.push(this._filters.join(''));
-            this._delete.push('\n');
-            this._delete.push('RETURNING');
-            this._delete.push('\n');
-            this._delete.push(this._fields.join(''));
-            return { query: this._delete.join(''), values: this._values };
-        };
-    }
-}
-exports.default = DeleteAggregator;

package/dist/builders/aggregators/insertAggregator.d.ts

@@ -1,22 +0,0 @@
-import { AbstractTable } from '../../tables';
-import { Indexing } from '../../tables/inferTypes';
-import { UpdateExpr } from '../requestBuilders/updates/updates';
-import Aggregator from './abstractAggregator';
-export default class InsertAggregator extends Aggregator {
-    private _onConflict;
-    private _columns;
-    private _query;
-    private _values;
-    private _from;
-    private _insert;
-    constructor(table: AbstractTable<any>);
-    appendColumns: () => void;
-    appendValues: (values: {
-        [name: string]: any;
-    }[]) => void;
-    appendOnConflict: (column: Indexing, updates?: UpdateExpr | undefined) => this;
-    buildQuery: () => {
-        query: string;
-        values: Array<any>;
-    };
-}