Develop

CHANGELOG.md

@@ -1,5 +1,109 @@
 # Changelog
 
+### 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

README.md

@@ -151,7 +151,7 @@ const usersTable = new UsersTable(db);
 const allSelect = await usersTable.select().all();
 
 // select first
-const firstSelect = await usersTable.select().first();
+const firstSelect = await usersTable.select().findOne();
 ```
 #### **Sorting and Filtering**
 ---
@@ -178,7 +178,7 @@ const orSelect = await usersTable.select().where(
 ```
 ##### Select all records from `Users` using **LIMIT** and **OFFSET**
 ```typescript
-const limitOffsetSelect = await usersTable.select({ limit: 10, offset: 10 }).all();
+const limitOffsetSelect = await usersTable.select().limit(10).offset(10).all();
 ```
 ##### Select all records from `Users` where `phone` contains `"hello"`
 ```typescript
@@ -232,6 +232,17 @@ const notEqSelect = usersTable.select().where(
 ```typescript
 const ordered = await usersTable.select().orderBy((table) => table.phone, Order.ASC).all();
 ```
+#### **Partial Selecting**
+ ```typescript
+    const partialSelect = await usersTable.select({
+      id: usersTable.id,
+      phone: usersTable.phone,
+    }).all();
+
+    // Usage
+    const { mappedId, mappedPhone } = partialSelect;
+ ```
+
 
 ### **Update**
 ---
@@ -254,7 +265,7 @@ await usersTable.update()
 await usersTable.update()
   .where(eq(usersTable.phone, 'hello'))
   .set({ fullName: 'newName' })
-  .first();
+  .findOne();
 ```
 
 ### **Delete**
@@ -274,7 +285,7 @@ await usersTable.delete()
 ```typescript
 await usersTable.delete()
       .where(eq(usersTable.phone, 'hello'))
-      .first();
+      .findOne();
 ```
 
 ### **Insert**
@@ -297,7 +308,7 @@ const user = await usersTable.insert({
 const user = await usersTable.insert({
   test: 1,
   createdAt: new Date(),
-}).first();
+}).findOne();
 ```
 ##### Insert many `users` with required fields and get all inserted entities
 ```typescript
@@ -349,7 +360,7 @@ const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user
       .leftJoin(UsersTable,
         (userToGroup) => userToGroup.userId,
         (users) => users.id)
-      .leftJoin(UserGroupsTable,
+      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,
         (userToGroup) => userToGroup.groupId,
         (users) => users.id)
       .execute();
@@ -371,7 +382,7 @@ const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user
       .leftJoin(UsersTable,
         (userToGroup) => userToGroup.userId,
         (users) => users.id)
-      .leftJoin(UserGroupsTable,
+      .leftJoin(UsersToUserGroupsTable, UserGroupsTable,
         (userToGroup) => userToGroup.groupId,
         (users) => users.id)
       .execute();
@@ -386,14 +397,33 @@ const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user
       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 `Migtator` class
+#### 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');
 ```
-##### Provide object with path to folder with migrations
+##### Another possibility is to provide object with path to folder with migrations
 ```typescript
 await drizzle.migrator(db).migrate({ migrationFolder: 'drizzle' });
 ```

package.json

@@ -1,6 +1,6 @@
 {
   "name": "drizzle-orm",
-  "version": "0.9.17",
+  "version": "0.9.19",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/builders/aggregators/abstractAggregator.ts

@@ -1,19 +1,26 @@
+/* eslint-disable max-len */
 import { AbstractColumn, Column } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
 import { AbstractTable } from '../../tables';
 import { ecranate } from '../../utils/ecranate';
 
+// eslint-disable-next-line max-len
 export default class Aggregator {
   protected _fields: Array<string> = [];
   protected _table: AbstractTable<any>;
 
-  public constructor(table: AbstractTable<any>) {
+  public constructor(table: AbstractTable<any>, partial?: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>}) {
     this._table = table;
-    this._fields = this.generateSelectArray(this._table.tableName(),
-      Object.values(this._table.mapServiceToDb()));
+    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));
+    }
   }
 
-  protected generateSelectArray = (table: string, columns: AbstractColumn<ColumnType>[]) => {
+  protected generateSelectArray = (table: string, columns: AbstractColumn<ColumnType>[], id?: number) => {
     const selectFields: string[] = [];
 
     columns.forEach((field: any) => {
@@ -23,7 +30,7 @@ export default class Aggregator {
         selectFields.push('.');
         selectFields.push(ecranate(field.getColumnName()));
         selectFields.push(' AS ');
-        selectFields.push(ecranate(`${table.replace('.', '_')}_${field.getColumnName()}`));
+        selectFields.push(ecranate(`${field.getAlias()}${id ? `_${id}` : ''}`));
         selectFields.push(',');
       }
     });

src/builders/aggregators/selectAggregator.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-len */
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
 import { AbstractTable } from '../../tables';
@@ -18,8 +19,10 @@ export default class SelectAggregator extends Aggregator {
   // private _groupBy: Array<string> = [];
   private _orderBy: Array<string> = [];
 
-  public constructor(table: AbstractTable<any>) {
-    super(table);
+  // public constructor(table: AbstractTable<any>);
+  // public constructor(table: AbstractTable<any>, partial: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>})
+  public constructor(table: AbstractTable<any>, partial?: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>}) {
+    super(table, partial);
   }
 
   public filters = (filters: Expr): SelectAggregator => {
@@ -70,29 +73,48 @@ export default class SelectAggregator extends Aggregator {
   };
 
   // Add select generator for second table also
-  public join = (joins: Array<Join<any> | undefined>): SelectAggregator => {
-    joins.forEach((join: Join<any> | undefined) => {
-      if (join) {
-        const tableFrom = join.fromColumn.getParentName();
-        const tableTo = join.toColumn.getParentName();
-        const { type } = join;
+  public join = (joins: Array<{
+    join: Join<any>, partial?: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>},
+    id?: number
+  }>): SelectAggregator => {
+    const cache: {[tableName: string]: string} = {};
+    joins.forEach((joinObject: {
+      join: Join<any>, partial?: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>},
+      id?: number
+    }) => {
+      if (joinObject) {
+        const tableFrom = joinObject.join.fromColumn.getParentName();
+        const tableTo = joinObject.join.toColumn.getParentName();
+        const { type } = joinObject.join;
 
-        const selectString = this.generateSelectArray(tableTo, Object.values(join.mappedServiceToDb)).join('');
+        let selectString;
+        if (joinObject.partial) {
+          selectString = this.generateSelectArray(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`, Object.values(joinObject.partial), joinObject.id).join('');
+        } else {
+          selectString = this.generateSelectArray(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`, Object.values(joinObject.join.mappedServiceToDb), joinObject.id).join('');
+        }
         this._fields.push(', ');
         this._fields.push(selectString);
         this._join.push('\n');
         this._join.push(type);
         this._join.push(' ');
         this._join.push(tableTo);
+        this._join.push(' ');
+        this._join.push(`AS ${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`);
         this._join.push('\n');
         this._join.push('ON ');
-        this._join.push(tableFrom);
+        if (cache[tableFrom]) {
+          this._join.push(cache[tableFrom]);
+        } else {
+          this._join.push(tableFrom);
+          cache[tableTo] = `${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`;
+        }
         this._join.push('.');
-        this._join.push(join.fromColumn.getColumnName());
+        this._join.push(joinObject.join.fromColumn.getColumnName());
         this._join.push(' = ');
-        this._join.push(tableTo);
+        this._join.push(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`);
         this._join.push('.');
-        this._join.push(join.toColumn.getColumnName());
+        this._join.push(joinObject.join.toColumn.getColumnName());
       }
     });