drizzle-orm 0.9.19 → 0.10.0

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

@@ -4,6 +4,8 @@ import { AbstractTable } from '../../tables';
 export default class Aggregator {
     protected _fields: Array<string>;
     protected _table: AbstractTable<any>;
-    constructor(table: AbstractTable<any>);
-    protected generateSelectArray: (table: string, columns: AbstractColumn<ColumnType>[]) => string[];
+    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/builders/aggregators/abstractAggregator.js

@@ -1,11 +1,13 @@
 "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) {
+    constructor(table, partial) {
         this._fields = [];
-        this.generateSelectArray = (table, columns) => {
+        this.generateSelectArray = (table, columns, id) => {
             const selectFields = [];
             columns.forEach((field) => {
                 if (field instanceof column_1.Column) {
@@ -14,7 +16,7 @@ class Aggregator {
                     selectFields.push('.');
                     selectFields.push(ecranate_1.ecranate(field.getColumnName()));
                     selectFields.push(' AS ');
-                    selectFields.push(ecranate_1.ecranate(`${table.replace('.', '_')}_${field.getColumnName()}`));
+                    selectFields.push(ecranate_1.ecranate(`${field.getAlias()}${id ? `_${id}` : ''}`));
                     selectFields.push(',');
                 }
             });
@@ -22,7 +24,12 @@ class Aggregator {
             return selectFields;
         };
         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));
+        }
     }
 }
 exports.default = Aggregator;

package/builders/aggregators/selectAggregator.d.ts

@@ -14,13 +14,21 @@ export default class SelectAggregator extends Aggregator {
     private _offset;
     private _distinct;
     private _orderBy;
-    constructor(table: AbstractTable<any>);
+    constructor(table: AbstractTable<any>, partial?: {
+        [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>;
+    });
     filters: (filters: Expr) => SelectAggregator;
     limit: (limit?: number | undefined) => SelectAggregator;
     offset: (offset?: number | undefined) => SelectAggregator;
-    orderBy: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined, order?: Order | undefined) => SelectAggregator;
-    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined) => SelectAggregator;
+    orderBy: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectAggregator;
+    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined) => SelectAggregator;
     appendFrom: (tableName: string) => SelectAggregator;
-    join: (joins: Array<Join<any> | undefined>) => SelectAggregator;
+    join: (joins: {
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        } | undefined;
+        id?: number | undefined;
+    }[]) => SelectAggregator;
     buildQuery: () => string;
 }

package/builders/aggregators/selectAggregator.js

@@ -4,8 +4,10 @@ const ecranate_1 = require("../../utils/ecranate");
 const order_1 = require("../highLvlBuilders/order");
 const abstractAggregator_1 = require("./abstractAggregator");
 class SelectAggregator extends abstractAggregator_1.default {
-    constructor(table) {
-        super(table);
+    // public constructor(table: AbstractTable<any>);
+    // public constructor(table: AbstractTable<any>, partial: {[name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, AbstractTable<any>>})
+    constructor(table, partial) {
+        super(table, partial);
         this._from = [];
         this._filters = [];
         this._select = ['SELECT'];
@@ -57,27 +59,42 @@ class SelectAggregator extends abstractAggregator_1.default {
         };
         // Add select generator for second table also
         this.join = (joins) => {
-            joins.forEach((join) => {
-                if (join) {
-                    const tableFrom = join.fromColumn.getParentName();
-                    const tableTo = join.toColumn.getParentName();
-                    const { type } = join;
-                    const selectString = this.generateSelectArray(tableTo, Object.values(join.mappedServiceToDb)).join('');
+            const cache = {};
+            joins.forEach((joinObject) => {
+                if (joinObject) {
+                    const tableFrom = joinObject.join.fromColumn.getParentName();
+                    const tableTo = joinObject.join.toColumn.getParentName();
+                    const { type } = joinObject.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());
                 }
             });
             return this;

package/builders/highLvlBuilders/abstractRequestBuilder.d.ts

@@ -4,7 +4,9 @@ import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel } from '../../tables/inferTypes';
-export default abstract class TableRequestBuilder<TTable extends AbstractTable<TTable>> {
+export default abstract class TableRequestBuilder<TTable extends AbstractTable<TTable>, TPartial extends {
+    [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>;
+} = {}> {
     protected _table: TTable;
     protected _session: ISession;
     protected _mappedServiceToDb: {
@@ -15,7 +17,11 @@ export default abstract class TableRequestBuilder<TTable extends AbstractTable<T
     constructor(table: AbstractTable<TTable>, session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, logger?: BaseLogger);
-    all: () => Promise<Array<ExtractModel<TTable> | undefined>>;
-    first: () => Promise<ExtractModel<TTable> | undefined>;
-    protected abstract _execute(): Promise<Array<ExtractModel<TTable> | undefined>>;
+    all: () => Promise<([keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>)[]>;
+    /**
+     * Current function will return an element only if response is of length 1
+     * If there are more or less than 1 element, will throw an Error
+     */
+    findOne: () => Promise<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>;
+    protected abstract _execute(): Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>>;
 }

package/builders/highLvlBuilders/abstractRequestBuilder.js

@@ -6,10 +6,21 @@ class TableRequestBuilder {
             const res = await this._execute();
             return res;
         };
-        this.first = async () => {
+        /**
+         * Current function will return an element only if response is of length 1
+         * If there are more or less than 1 element, will throw an Error
+         */
+        this.findOne = async () => {
             const executionRes = await this._execute();
-            // TODO add checks for undefined or null
-            return executionRes[0];
+            if (executionRes.length > 1) {
+                throw new Error('Request contains more than 1 element');
+            }
+            else if (executionRes.length < 1) {
+                throw new Error('Request contains less than 1 element ');
+            }
+            else {
+                return executionRes[0];
+            }
         };
         this._mappedServiceToDb = mappedServiceToDb;
         this._table = table;

package/builders/highLvlBuilders/deleteRequestBuilder.d.ts

@@ -6,12 +6,14 @@ import { AbstractTable } from '../../tables';
 import { ExtractModel } from '../../tables/inferTypes';
 import Expr from '../requestBuilders/where/where';
 import TableRequestBuilder from './abstractRequestBuilder';
-export default class DeleteTRB<TTable extends AbstractTable<TTable>> extends TableRequestBuilder<TTable> {
+export default class DeleteTRB<TTable extends AbstractTable<TTable>, TPartial extends {
+    [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>;
+} = {}> extends TableRequestBuilder<TTable, TPartial> {
     private _filter;
     constructor(table: AbstractTable<TTable>, session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, logger?: BaseLogger);
     where: (expr: Expr) => DeleteTRB<TTable>;
     execute: () => Promise<void>;
-    protected _execute: () => Promise<Array<ExtractModel<TTable> | undefined>>;
+    protected _execute: () => Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>>;
 }

package/builders/highLvlBuilders/insertRequestBuilder.d.ts

@@ -5,7 +5,9 @@ import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel, Indexing } from '../../tables/inferTypes';
 import TableRequestBuilder from './abstractRequestBuilder';
-export default class InsertTRB<TTable extends AbstractTable<TTable>> extends TableRequestBuilder<TTable> {
+export default class InsertTRB<TTable extends AbstractTable<TTable>, TPartial extends {
+    [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>;
+} = {}> extends TableRequestBuilder<TTable, TPartial> {
     private _values;
     private _onConflict;
     private _onConflictField;
@@ -14,5 +16,5 @@ export default class InsertTRB<TTable extends AbstractTable<TTable>> extends Tab
     }, table: AbstractTable<TTable>, logger?: BaseLogger);
     execute: () => Promise<void>;
     onConflict: (callback: (table: TTable) => Indexing, update: Partial<ExtractModel<TTable>>) => InsertTRB<TTable>;
-    protected _execute: () => Promise<Array<ExtractModel<TTable> | undefined>>;
+    protected _execute: () => Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>>;
 }

package/builders/highLvlBuilders/insertRequestBuilder.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
 const __1 = require("..");
 const builderError_1 = require("../../errors/builderError");
 const responseMapper_1 = require("../../mappers/responseMapper");

package/builders/highLvlBuilders/selectRequestBuilder.d.ts

@@ -4,39 +4,44 @@ import DB from '../../db/db';
 import { ISession } from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
-import { ExtractModel } from '../../tables/inferTypes';
+import { ExtractModel, PartialFor } from '../../tables/inferTypes';
 import SelectTRBWithJoin from '../joinBuilders/builders/selectWithJoin';
 import Expr from '../requestBuilders/where/where';
 import TableRequestBuilder from './abstractRequestBuilder';
 import Order from './order';
-export default class SelectTRB<TTable extends AbstractTable<TTable>> extends TableRequestBuilder<TTable> {
+export default class SelectTRB<TTable extends AbstractTable<TTable>, TPartial extends {
+    [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>;
+} = {}> extends TableRequestBuilder<TTable, TPartial> {
     protected _filter: Expr;
     private props;
     private __orderBy?;
     private __groupBy?;
     private __order?;
     private __distinct;
+    private __partial?;
     constructor(session: ISession, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, props: {
         limit?: number;
         offset?: number;
-    }, table: AbstractTable<TTable>, logger?: BaseLogger);
-    where: (expr: Expr) => SelectTRB<TTable>;
-    orderBy<TColumnType extends ColumnType>(callback: (table: TTable) => AbstractColumn<TColumnType, boolean, boolean>, order: Order): SelectTRB<TTable>;
-    distinct: (column: AbstractColumn<ColumnType<any>, boolean, boolean>) => SelectTRB<TTable>;
-    innerJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, table: AbstractTable<TTable>, logger?: BaseLogger, partial?: TPartial);
+    where: (expr: Expr) => SelectTRB<TTable, TPartial>;
+    orderBy<TColumnType extends ColumnType>(callback: (table: TTable) => AbstractColumn<TColumnType, boolean, boolean>, order: Order): SelectTRB<TTable, TPartial>;
+    distinct: (column: AbstractColumn<ColumnType<any>, boolean, boolean>) => SelectTRB<TTable, TPartial>;
+    limit: (limit: number) => SelectTRB<TTable, TPartial>;
+    offset: (offset: number) => SelectTRB<TTable, TPartial>;
+    innerJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithJoin<TTable, IToTable>;
-    leftJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial>;
+    leftJoin<TColumn extends ColumnType<any>, IToColumn extends ColumnType<any>, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithJoin<TTable, IToTable>;
-    rightJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean, TTable>, to: (table: IToTable) => AbstractColumn<IToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial>;
+    rightJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithJoin<TTable, IToTable>;
-    fullJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial>;
+    fullJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(table: {
         new (db: DB): IToTable;
-    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithJoin<TTable, IToTable>;
-    execute: () => Promise<(ExtractModel<TTable> | undefined)[]>;
-    protected _execute: () => Promise<Array<ExtractModel<TTable> | undefined>>;
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial>;
+    execute: () => Promise<([keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>)[]>;
+    protected _execute: () => Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>>;
 }

package/builders/highLvlBuilders/selectRequestBuilder.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable import/no-cycle */
 const __1 = require("..");
 const builderError_1 = require("../../errors/builderError");
 const responseMapper_1 = require("../../mappers/responseMapper");
@@ -8,7 +7,7 @@ const selectWithJoin_1 = require("../joinBuilders/builders/selectWithJoin");
 const join_1 = require("../joinBuilders/join");
 const abstractRequestBuilder_1 = require("./abstractRequestBuilder");
 class SelectTRB extends abstractRequestBuilder_1.default {
-    constructor(session, mappedServiceToDb, props, table, logger) {
+    constructor(session, mappedServiceToDb, props, table, logger, partial) {
         super(table, session, mappedServiceToDb, logger);
         this.where = (expr) => {
             this._filter = expr;
@@ -18,6 +17,14 @@ class SelectTRB extends abstractRequestBuilder_1.default {
             this.__distinct = column;
             return this;
         };
+        this.limit = (limit) => {
+            this.props.limit = limit;
+            return this;
+        };
+        this.offset = (offset) => {
+            this.props.offset = offset;
+            return this;
+        };
         this.execute = async () => {
             const res = await this._execute();
             return res;
@@ -25,7 +32,7 @@ class SelectTRB extends abstractRequestBuilder_1.default {
         this._execute = async () => {
             // Select.from().filteredBy().limit().offset().orderBy().groupBy().build()
             const queryBuilder = __1.Select
-                .from(this._table)
+                .from(this._table, this.__partial)
                 .distinct(this.__distinct)
                 .filteredBy(this._filter)
                 .limit(this.props.limit)
@@ -42,9 +49,13 @@ class SelectTRB extends abstractRequestBuilder_1.default {
                 this._logger.info(`Selecting from ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
+            if (this.__partial) {
+                return responseMapper_1.default.partialMap(this.__partial, result);
+            }
             return responseMapper_1.default.map(this._mappedServiceToDb, result);
         };
         this.props = props;
+        this.__partial = partial;
     }
     orderBy(callback, order) {
         this.__orderBy = callback(this._table);
@@ -56,37 +67,37 @@ class SelectTRB extends abstractRequestBuilder_1.default {
     //   this.__groupBy = callback(this.__table);
     //   return this;
     // }
-    innerJoin(table, from, to) {
+    innerJoin(table, from, to, partial) {
         const toTable = this._table.db.create(table);
         const fromColumn = from(this._table);
         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);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct, this.__partial, partial);
     }
-    leftJoin(table, from, to) {
+    leftJoin(table, from, to, partial) {
         const toTable = this._table.db.create(table);
         const fromColumn = from(this._table);
         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);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct, this.__partial, partial);
     }
-    rightJoin(table, from, to) {
+    rightJoin(table, from, to, partial) {
         const toTable = this._table.db.create(table);
         const fromColumn = from(this._table);
         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);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct, this.__partial, partial);
     }
-    fullJoin(table, from, to) {
+    fullJoin(table, from, to, partial) {
         const toTable = this._table.db.create(table);
         const fromColumn = from(this._table);
         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);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct, this.__partial, partial);
     }
 }
 exports.default = SelectTRB;

package/builders/highLvlBuilders/updateRequestBuilder.d.ts

@@ -6,7 +6,9 @@ import { AbstractTable } from '../../tables';
 import { ExtractModel, ExtractUpdateModel } from '../../tables/inferTypes';
 import Expr from '../requestBuilders/where/where';
 import TableRequestBuilder from './abstractRequestBuilder';
-export default class UpdateTRB<TTable extends AbstractTable<TTable>> extends TableRequestBuilder<TTable> {
+export default class UpdateTRB<TTable extends AbstractTable<TTable>, TPartial extends {
+    [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>;
+} = {}> extends TableRequestBuilder<TTable, TPartial> {
     private _filter;
     private _update;
     private _objToUpdate;
@@ -16,5 +18,5 @@ export default class UpdateTRB<TTable extends AbstractTable<TTable>> extends Tab
     where: (expr: Expr) => UpdateTRB<TTable>;
     set: (expr: Partial<ExtractUpdateModel<TTable>>) => UpdateTRB<TTable>;
     execute: () => Promise<void>;
-    protected _execute: () => Promise<Array<ExtractModel<TTable> | undefined>>;
+    protected _execute: () => Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>>;
 }

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

@@ -3,10 +3,11 @@ import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import { ISession } from '../../../db/session';
 import { AbstractTable } from '../../../tables';
+import { ExtractModel, FullOrPartial, PartialFor } from '../../../tables/inferTypes';
 import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
 import Join from '../join';
-export default abstract class AbstractJoined<TTable extends AbstractTable<TTable>, TRes> {
+export default abstract class AbstractJoined<TTable extends AbstractTable<TTable>, TRes, TPartial extends PartialFor<TTable> = {}> {
     protected _table: TTable;
     protected _session: ISession;
     protected _filter: Expr;
@@ -17,11 +18,23 @@ export default abstract class AbstractJoined<TTable extends AbstractTable<TTable
     };
     protected _orderBy?: AbstractColumn<ColumnType, boolean, boolean>;
     protected _order?: Order;
+    protected _partial?: TPartial;
     constructor(table: TTable, filter: Expr, session: ISession, props: {
         limit?: number;
         offset?: number;
-    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial);
+    limit: (limit: number) => this;
+    offset: (offset: number) => this;
     execute: () => Promise<TRes>;
+    protected fullOrPartial<Table extends AbstractTable<Table>, Partial extends PartialFor<Table>>(mappedServiceToDb: {
+        [name in keyof ExtractModel<Table>]: AbstractColumn<ColumnType>;
+    }, result: QueryResult<any>, partial?: Partial, joinId?: number): Array<FullOrPartial<Table, Partial>>;
     protected abstract mapResponse(result: QueryResult<any>): TRes;
-    protected abstract joins(): Array<Join<any>>;
+    protected abstract joins(): Array<{
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        };
+        id?: number;
+    }>;
 }

package/builders/joinBuilders/builders/abstractJoinBuilder.js

@@ -1,12 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const builderError_1 = require("../../../errors/builderError");
+const responseMapper_1 = require("../../../mappers/responseMapper");
 const select_1 = require("../../lowLvlBuilders/selects/select");
 class AbstractJoined {
-    constructor(table, filter, session, props, orderBy, order, distinct) {
+    constructor(table, filter, session, props, orderBy, order, distinct, tablePartial) {
+        this.limit = (limit) => {
+            this._props.limit = limit;
+            return this;
+        };
+        this.offset = (offset) => {
+            this._props.offset = offset;
+            return this;
+        };
         this.execute = async () => {
             const queryBuilder = select_1.default
-                .from(this._table)
+                .from(this._table, this._partial)
                 .distinct(this._distinct)
                 .joined(this.joins())
                 .limit(this._props.limit)
@@ -16,6 +25,7 @@ class AbstractJoined {
             let query = '';
             try {
                 query = queryBuilder.build();
+                console.log(query);
             }
             catch (e) {
                 throw new builderError_1.default(builderError_1.BuilderType.JOINED_SELECT, this._table.tableName(), Object.values(this._table.mapServiceToDb()), e, this._filter);
@@ -30,6 +40,13 @@ class AbstractJoined {
         this._order = order;
         this._orderBy = orderBy;
         this._distinct = distinct;
+        this._partial = tablePartial;
+    }
+    fullOrPartial(mappedServiceToDb, result, partial, joinId) {
+        if (partial) {
+            return responseMapper_1.default.partialMap(partial, result, joinId);
+        }
+        return responseMapper_1.default.map(mappedServiceToDb, result, joinId);
     }
 }
 exports.default = AbstractJoined;