drizzle-orm 0.10.25 → 0.10.28

package/.eslintrc

@@ -0,0 +1,28 @@
+{
+    "extends": ["airbnb-typescript/base"],
+    "plugins": ["prefer-arrow"],
+    "parserOptions": {
+        "project": "./orm/tsconfig.json"
+    },
+    "rules": {
+        "@typescript-eslint/explicit-member-accessibility": "error",
+        "@typescript-eslint/lines-between-class-members": ["error", "always", { "exceptAfterSingleLine": true }],
+        "no-underscore-dangle": ["off"],
+        "@typescript-eslint/member-ordering": ["error", { "default": [
+          "public-field",
+          "protected-field",
+          "private-field",
+          "constructor",
+          "static-method",
+          "public-method",
+          "protected-method",
+          "private-method"
+          ] }],
+        "class-methods-use-this": "off",
+        "import/no-named-as-default": 0,
+        "import/no-named-as-default-member": 0,
+        // "prefer-arrow/prefer-arrow-functions": ["error", { "classPropertiesAllowed": true }],
+        "import/no-extraneous-dependencies": ["error", { "devDependencies": ["webpack.config.ts"] }],
+        "linebreak-style": 0
+    }
+}

package/.tslintignore

@@ -0,0 +1 @@
+*.test.ts

package/CHANGELOG.md

@@ -0,0 +1,202 @@
+# Changelog
+
+### 0.10.6 (Fabruary 06, 2022)
+### Fixes and Functionality:
+- Move from simple query execution to parameterized queries
+### Breaking changes:
+- For `raw` query execution you need to provide values together with query
+#### Previous you could run simple query
+```typescript
+const res: QueryResult<any> = await db.session().execute('SELECT * FROM users WHERE user.id = 1');
+```
+#### Currently you need to provide prepared statement with values as array
+```typescript
+const res: QueryResult<any> = await db.session().execute('SELECT * FROM users WHERE user.id = $1', [1]);
+```
+It's still possible to execute query as before, without providing any values array. But we highly recommend to separate those
+
+---
+### 0.10.4 (Fabruary 02, 2022)
+### Fixes and Functionality:
+- Fix `int` and `smallint` mappings from pg driver
+---
+### 0.10.0 (January 27, 2022)
+### Breaking changes:
+ - Move limit offset to function calls
+ #### Previous limit/offset usage:
+ ```typescript
+ await usersTable.select({limit: 20, offset: 20}).all();
+ ```
+ #### Current limit/offset usage:
+ ```typescript
+ await usersTable.select().limit(20).offset(20).all();
+ ```
+ - Change join calls starting from second one
+
+ Starting from second join you need to provide table to join from. As long as PostgreSQL has a possibility to join on tables, that already were in previous joins, we need to have a possibility to clarify from which exact table we need to join
+  #### Previous join funcition call with parameters:
+  ```typescript
+  await usersToUserGroupsTable.select()
+      .where(eq(userGroupsTable.id, 1))
+      .leftJoin(UsersTable,
+        (userToGroup) => userToGroup.userId,
+        (users) => users.id)
+      .leftJoin(UserGroupsTable,
+        (userToGroup) => userToGroup.groupId,
+        (userGroup) => userGroup.id)
+      .execute()
+  ```
+  #### Current join funcition call with parameters:
+  ```typescript
+  await usersToUserGroupsTable.select()
+      .where(eq(userGroupsTable.id, 1))
+      .leftJoin(UsersTable,
+        (userToGroup) => userToGroup.userId,
+        (users) => users.id)
+      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,
+        (userToGroup) => userToGroup.groupId,
+        (userGroup) => userGroup.id)
+      .execute()
+  ```
+ - Create partial select on simple select + on each join
+
+ If you want to select only specific fields from select request you could provide your own interface with columns to map to:
+ #### Example
+ ```typescript
+    const partialSelect = await usersTable.select({
+      id: usersTable.id,
+      phone: usersTable.phone,
+    }).all();
+
+    // Usage
+    const { mappedId, mappedPhone } = partialSelect;
+ ```
+
+Same could be done with specific columns selecting on joined tables
+#### Example
+```typescript
+    const usersWithUserGroups = await usersToUserGroupsTable.select()
+      .where(eq(userGroupsTable.id, 1))
+      .leftJoin(UsersTable,
+        (userToGroup) => userToGroup.userId,
+        (users) => users.id,
+        // Partial fields to be selected from UsersTable
+        {
+          id: usersTable.id,
+        })
+      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,
+        (userToGroup) => userToGroup.groupId,
+        (userGroup) => userGroup.id,
+        // Partial fields to be selected from UserGroupsTable
+        {
+          id: userGroupsTable.id,
+        })
+      .execute();
+```
+
+ - Create possibility to have self FK and self joins
+ 
+ You could create FK on same table you are creating it from
+ #### Example
+ ```typescript
+ public cityId = this.int('city_id').foreignKey(CitiesTable, (table) => table.id, { onUpdate: 'CASCADE' });
+ ```
+ - Delete first() on execution and add findOne(), that will throw an error
+
+ Previously we had `.first()` function, that was just getting first element from rows returned from `pg` driver
+ Right now, invoking `.findOne()` function should check if response contains exactly 1 element in repsponse. If not, it will throw an error
+ ### Example
+ ```typescript
+const firstSelect = await usersTable.select().findOne();
+ ```
+ - Fix wrong types. Right now you won't get undefined from select query
+---
+
+### 0.9.19 (January 24, 2022)
+### Fixes and Functionality:
+- Fix all queries by `Date`
+
+---
+
+### 0.9.18 (December 28, 2021)
+### Fixes and Functionality:
+- Fix `any` type returning from `.notNull()` and `.primaryKey()` functions
+
+---
+
+### 0.9.17 (December 27, 2021)
+### Fixes and Functionality:
+- Add serializer `fromDb()` method to introspect selected database to drizzle-kit json shanpsot format
+
+---
+### 0.9.16 (December 27, 2021)
+### Breaking changes:
+- Delete `autoincrement` type on columns. Right now you should use `serial` type
+
+#### Previous serial column defining:
+```typescript
+public id = this.int('id').autoincrement();
+```
+#### Current serial column defining:
+```typescript
+public id = this.serial('id');
+```
+
+- Move `notNull` from column type metadata to builder chain
+#### Previous notNull defining:
+```typescript
+public phone = this.varchar('phone', { notNull: true });
+```
+#### Current notNull defining:
+```typescript
+public phone = this.varchar('phone').notNull();
+```
+
+- Divide `BigInt` into 2 types -> `BigInt53` and `BigInt64`
+- Divide `BigSerial` into 2 types -> `BigSerial53` and `BigSerial64`
+
+    Due to have max value for big integers in postgres as 2^64 and javascript max value for integers is 2^53
+
+    If you sure, that value in this column won't be more than 2^53 you could use:
+    ```typescript
+    public bigIntField = this.bigint('test1', 'max_bytes_53');
+    ```
+    that will be of type `number` in typescript
+
+    If value in this column could be more than 2^53 you could use:
+    ```typescript
+    public bigIntField = this.bigint('test1', 'max_bytes_64');
+    ```
+    that will be of type `bigint` in typescript
+---
+
+### Fixes and Functionality:
+- Add `SET NULL` and `SET DEFAULT` for `ON DELETE` and `ON UPDATE` constraints
+
+#### Example of usage
+```typescript
+public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onUpdate: 'SET NULL' });
+
+public userId = this.int('user_id').foreignKey(UsersTable, (table) => table.id, { onDelete: 'SET DEFAULT' });
+```
+- Add default value for timestamp
+```typescript
+public createdAt = this.timestamp('created_at').defaultValue(Defaults.CURRENT_TIMESTAMP);
+```
+- Add `timestamp with timezone` type
+```typescript
+public createdAt = this.timestamptz('created_at');
+```
+- Add migrator function to use `drizzle-kit` generated migrations
+##### 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' });
+```
+---
+
+### Documentation:
+- Change README documentation for all changes in current release

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/dist/builders/aggregators/abstractAggregator.d.ts

@@ -0,0 +1,11 @@
+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[];
+}