drizzle-orm 0.9.1 → 0.9.5

package/builders/aggregators/abstractAggregator.d.ts

@@ -1,10 +1,9 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
+import { AbstractTable } from '../../tables';
 export default class Aggregator {
     protected _fields: Array<string>;
-    protected _tableName: string;
-    protected _columnsTypes: AbstractColumn<ColumnType>[];
-    constructor(tableName: string);
-    appendFields: (columns: AbstractColumn<ColumnType>[]) => void;
+    protected _table: AbstractTable<any>;
+    constructor(table: AbstractTable<any>);
     protected generateSelectArray: (table: string, columns: AbstractColumn<ColumnType>[]) => string[];
 }

package/builders/aggregators/abstractAggregator.js

@@ -3,12 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const column_1 = require("../../columns/column");
 const ecranate_1 = require("../../utils/ecranate");
 class Aggregator {
-    constructor(tableName) {
+    constructor(table) {
         this._fields = [];
-        this.appendFields = (columns) => {
-            this._fields = this.generateSelectArray(this._tableName, columns);
-            this._columnsTypes = columns;
-        };
         this.generateSelectArray = (table, columns) => {
             const selectFields = [];
             columns.forEach((field) => {
@@ -16,16 +12,17 @@ class Aggregator {
                     selectFields.push(' ');
                     selectFields.push(table);
                     selectFields.push('.');
-                    selectFields.push((0, ecranate_1.ecranate)(field.getColumnName()));
+                    selectFields.push(ecranate_1.ecranate(field.getColumnName()));
                     selectFields.push(' AS ');
-                    selectFields.push((0, ecranate_1.ecranate)(`${table.replace('.', '_')}_${field.getColumnName()}`));
+                    selectFields.push(ecranate_1.ecranate(`${table.replace('.', '_')}_${field.getColumnName()}`));
                     selectFields.push(',');
                 }
             });
             selectFields.pop();
             return selectFields;
         };
-        this._tableName = tableName;
+        this._table = table;
+        this._fields = this.generateSelectArray(this._table.tableName(), Object.values(this._table.mapServiceToDb()));
     }
 }
 exports.default = Aggregator;

package/builders/aggregators/deleteAggregator.d.ts

@@ -1,10 +1,11 @@
+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 _delete;
-    constructor(tableName: string);
+    constructor(table: AbstractTable<any>);
     filters: (filters: Expr) => DeleteAggregator;
     appendFrom: (tableName: string) => DeleteAggregator;
     buildQuery: () => string;

package/builders/aggregators/deleteAggregator.js

@@ -2,14 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const abstractAggregator_1 = require("./abstractAggregator");
 class DeleteAggregator extends abstractAggregator_1.default {
-    constructor(tableName) {
-        super(tableName);
+    constructor(table) {
+        super(table);
         this._from = [];
         this._filters = [];
         this._delete = ['DELETE'];
         this.filters = (filters) => {
-            this._filters.push('WHERE ');
-            this._filters.push(filters.toQuery());
+            if (filters) {
+                this._filters.push('WHERE ');
+                this._filters.push(filters.toQuery());
+            }
             return this;
         };
         this.appendFrom = (tableName) => {
@@ -23,6 +25,10 @@ class DeleteAggregator extends abstractAggregator_1.default {
             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 this._delete.join('');
         };
     }

package/builders/aggregators/insertAggregator.d.ts

@@ -1,5 +1,4 @@
-import { Column } from '../../columns/column';
-import ColumnType from '../../columns/types/columnType';
+import { AbstractTable } from '../../tables';
 import { Indexing } from '../../tables/inferTypes';
 import UpdateExpr from '../requestBuilders/updates/updates';
 import Aggregator from './abstractAggregator';
@@ -9,10 +8,9 @@ export default class InsertAggregator extends Aggregator {
     private _values;
     private _from;
     private _insert;
-    constructor(tableName: string);
-    appendFrom: (tableName: string) => InsertAggregator;
-    appendColumns: <T>(values: T[]) => void;
-    appendValues: <T>(mapper: { [name in keyof T]: Column<ColumnType<{}>, true, false>; }, values: {
+    constructor(table: AbstractTable<any>);
+    appendColumns: () => void;
+    appendValues: (values: {
         [name: string]: any;
     }[]) => void;
     appendOnConflict: (column: Indexing, updates?: UpdateExpr | undefined) => this;

package/builders/aggregators/insertAggregator.js

@@ -3,57 +3,52 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const column_1 = require("../../columns/column");
 const abstractAggregator_1 = require("./abstractAggregator");
 class InsertAggregator extends abstractAggregator_1.default {
-    constructor(tableName) {
-        super(tableName);
+    constructor(table) {
+        super(table);
         this._onConflict = [];
         this._columns = [];
         this._values = [];
         this._from = [];
         this._insert = ['INSERT INTO'];
-        this.appendFrom = (tableName) => {
-            this._from.push(' ');
-            this._from.push(tableName);
-            this._tableName = tableName;
-            return this;
-        };
-        // @TODO refactor!!
-        this.appendColumns = (values) => {
-            // @TODO Check if values not empty
-            const columns = Object.keys(values[0]);
+        this.appendColumns = () => {
+            const mapper = this._table.mapServiceToDb();
+            const columns = Object.values(mapper);
             for (let i = 0; i < columns.length; i += 1) {
                 const column = columns[i];
                 this._columns.push('"');
-                this._columns.push(column);
+                this._columns.push(column.getColumnName());
                 this._columns.push('"');
                 if (i < columns.length - 1) {
                     this._columns.push(', ');
                 }
             }
         };
-        // @TODO refactor!!
-        this.appendValues = (mapper, values) => {
+        this.appendValues = (values) => {
             // @TODO Check if values not empty
+            const mapper = this._table.mapServiceToDb();
             for (let i = 0; i < values.length; i += 1) {
                 const value = values[i];
-                const insertValues = Object.values(value);
-                const insertKeys = Object.keys(value);
                 this._values.push('(');
-                for (let j = 0; j < insertValues.length; j += 1) {
-                    const insertValue = insertValues[j];
-                    const insertKey = insertKeys[j];
-                    const columnKey = Object.keys(mapper)
-                        .find((it) => mapper[it].getColumnName() === insertKey);
-                    const column = mapper[columnKey];
-                    if (insertValue !== undefined && insertValue !== null) {
-                        this._values.push(column.getColumnType().insertStrategy(insertValue));
+                const entries = Object.entries(mapper);
+                entries.forEach(([key], index) => {
+                    const valueToInsert = value[key];
+                    const isKeyExistsInValue = key.toString() in value;
+                    const column = mapper[key];
+                    if (isKeyExistsInValue) {
+                        if (valueToInsert !== undefined && valueToInsert !== null) {
+                            this._values.push(column.getColumnType().insertStrategy(valueToInsert));
+                        }
+                        else {
+                            this._values.push('null');
+                        }
                     }
                     else {
-                        this._values.push('null');
+                        this._values.push('DEFAULT');
                     }
-                    if (j < insertValues.length - 1) {
+                    if (index < entries.length - 1) {
                         this._values.push(', ');
                     }
-                }
+                });
                 if (i < values.length - 1) {
                     this._values.push('),\n');
                 }
@@ -63,14 +58,17 @@ class InsertAggregator extends abstractAggregator_1.default {
             }
         };
         this.appendOnConflict = (column, updates) => {
-            const indexName = column instanceof column_1.IndexedColumn ? column.getColumnName() : column.indexName();
-            this._onConflict.push(`ON CONFLICT ON CONSTRAINT ${indexName}\n`);
-            if (updates) {
-                this._onConflict.push('DO UPDATE\n');
-                this._onConflict.push(`SET ${updates.toQuery()}`);
-            }
-            else {
-                this._onConflict.push('DO NOTHING\n');
+            if (column) {
+                const indexName = column instanceof column_1.IndexedColumn
+                    ? column.getColumnName() : column.getColumns().map((it) => it.getColumnName()).join(',');
+                this._onConflict.push(`ON CONFLICT (${indexName})\n`);
+                if (updates) {
+                    this._onConflict.push('DO UPDATE\n');
+                    this._onConflict.push(`SET ${updates.toQuery()}`);
+                }
+                else {
+                    this._onConflict.push('DO NOTHING\n');
+                }
             }
             return this;
         };
@@ -82,20 +80,15 @@ class InsertAggregator extends abstractAggregator_1.default {
             this._insert.push('VALUES\n');
             this._insert.push(this._values.join(''));
             this._insert.push('\n');
+            this._insert.push(this._onConflict.join(''));
             this._insert.push('\n');
             this._insert.push('RETURNING');
             this._insert.push('\n');
             this._insert.push(this._fields.join(''));
-            this._insert.push('\n');
-            this._insert.push(this._onConflict.join(''));
-            // this._insert.push("ON CONFLICT ON CONSTRAINT \"");
-            // this._insert.push(this._table.tableName());
-            // this._insert.push("_");
-            // this._insert.push(this._table);
-            // this._insert.push("\n");
-            // this._insert.push(this._fields.join(''));
             return this._insert.join('');
         };
+        this._from.push(' ');
+        this._from.push(table.tableName());
     }
 }
 exports.default = InsertAggregator;

package/builders/aggregators/selectAggregator.d.ts

@@ -1,5 +1,6 @@
 import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
+import { AbstractTable } from '../../tables';
 import Order from '../highLvlBuilders/order';
 import Join from '../joinBuilders/join';
 import Expr from '../requestBuilders/where/where';
@@ -11,13 +12,15 @@ export default class SelectAggregator extends Aggregator {
     private _join;
     private _limit;
     private _offset;
+    private _distinct;
     private _orderBy;
-    constructor(tableName: string);
+    constructor(table: AbstractTable<any>);
     filters: (filters: Expr) => SelectAggregator;
-    limit: (limit: number) => SelectAggregator;
-    offset: (limit: number) => SelectAggregator;
-    orderBy: (column: AbstractColumn<ColumnType, boolean, boolean>, order: Order) => 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;
     appendFrom: (tableName: string) => SelectAggregator;
-    join: (joins: Array<Join<{}>>) => SelectAggregator;
+    join: (joins: Array<Join<any> | undefined>) => SelectAggregator;
     buildQuery: () => string;
 }

package/builders/aggregators/selectAggregator.js

@@ -1,37 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const ecranate_1 = require("../../utils/ecranate");
 const order_1 = require("../highLvlBuilders/order");
 const abstractAggregator_1 = require("./abstractAggregator");
 class SelectAggregator extends abstractAggregator_1.default {
-    constructor(tableName) {
-        super(tableName);
+    constructor(table) {
+        super(table);
         this._from = [];
         this._filters = [];
         this._select = ['SELECT'];
         this._join = [];
         this._limit = [];
         this._offset = [];
+        this._distinct = [];
         // private _groupBy: Array<string> = [];
         this._orderBy = [];
         this.filters = (filters) => {
-            this._filters.push('WHERE ');
-            this._filters.push(filters.toQuery());
+            if (filters) {
+                this._filters.push('WHERE ');
+                this._filters.push(filters.toQuery());
+            }
             return this;
         };
         this.limit = (limit) => {
-            this._limit.push('LIMIT ');
-            this._limit.push(limit.toString());
+            if (limit) {
+                this._limit.push('LIMIT ');
+                this._limit.push(limit.toString());
+            }
             return this;
         };
-        this.offset = (limit) => {
-            this._offset.push('OFFSET ');
-            this._offset.push(limit.toString());
+        this.offset = (offset) => {
+            if (offset) {
+                this._offset.push('OFFSET ');
+                this._offset.push(offset.toString());
+            }
             return this;
         };
         this.orderBy = (column, order) => {
-            this._orderBy.push('ORDER BY ');
-            this._orderBy.push(`${column.getColumnName()} `);
-            this._orderBy.push(order_1.default[order]);
+            if (column !== null && column !== undefined) {
+                this._orderBy.push('ORDER BY ');
+                this._orderBy.push(`${column.getColumnName()} `);
+                this._orderBy.push(order_1.default[order]);
+            }
+            return this;
+        };
+        this.distinct = (column) => {
+            if (column) {
+                this._distinct.push(` DISTINCT ON(${column.getParent()}.${ecranate_1.ecranate(column.getColumnName())}) `);
+            }
             return this;
         };
         this.appendFrom = (tableName) => {
@@ -42,29 +58,32 @@ class SelectAggregator extends abstractAggregator_1.default {
         // Add select generator for second table also
         this.join = (joins) => {
             joins.forEach((join) => {
-                const tableFrom = join.fromColumn.getParentName();
-                const tableTo = join.toColumn.getParentName();
-                const { type } = join;
-                const selectString = this.generateSelectArray(tableTo, Object.values(join.mappedServiceToDb)).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('\n');
-                this._join.push('ON ');
-                this._join.push(tableFrom);
-                this._join.push('.');
-                this._join.push(join.fromColumn.getColumnName());
-                this._join.push(' = ');
-                this._join.push(tableTo);
-                this._join.push('.');
-                this._join.push(join.toColumn.getColumnName());
+                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('');
+                    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('\n');
+                    this._join.push('ON ');
+                    this._join.push(tableFrom);
+                    this._join.push('.');
+                    this._join.push(join.fromColumn.getColumnName());
+                    this._join.push(' = ');
+                    this._join.push(tableTo);
+                    this._join.push('.');
+                    this._join.push(join.toColumn.getColumnName());
+                }
             });
             return this;
         };
         this.buildQuery = () => {
+            this._select.push(this._distinct.join(''));
             this._select.push(this._fields.join(''));
             this._select.push('\n');
             this._select.push(this._from.join(''));

package/builders/aggregators/updateAggregator.d.ts

@@ -1,3 +1,4 @@
+import { AbstractTable } from '../../tables';
 import UpdateExpr from '../requestBuilders/updates/updates';
 import Expr from '../requestBuilders/where/where';
 import Aggregator from './abstractAggregator';
@@ -6,7 +7,7 @@ export default class UpdateAggregator extends Aggregator {
     private _filters;
     private _from;
     private _update;
-    constructor(tableName: string);
+    constructor(table: AbstractTable<any>);
     where: (filters: Expr) => UpdateAggregator;
     appendFrom: (tableName: string) => UpdateAggregator;
     set: (updates: UpdateExpr) => UpdateAggregator;

package/builders/aggregators/updateAggregator.js

@@ -2,15 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const abstractAggregator_1 = require("./abstractAggregator");
 class UpdateAggregator extends abstractAggregator_1.default {
-    constructor(tableName) {
-        super(tableName);
+    constructor(table) {
+        super(table);
         this._updates = [];
         this._filters = [];
         this._from = [];
         this._update = ['UPDATE'];
         this.where = (filters) => {
-            this._filters.push('WHERE ');
-            this._filters.push(filters.toQuery());
+            if (filters) {
+                this._filters.push('WHERE ');
+                this._filters.push(filters.toQuery());
+            }
             return this;
         };
         this.appendFrom = (tableName) => {

package/builders/highLvlBuilders/abstractRequestBuilder.d.ts

@@ -2,16 +2,17 @@ import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
 import Session from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
+import { AbstractTable } from '../../tables';
 import { ExtractModel } from '../../tables/inferTypes';
-export default abstract class TableRequestBuilder<TTable> {
-    protected _tableName: string;
+export default abstract class TableRequestBuilder<TTable extends AbstractTable<TTable>> {
+    protected _table: TTable;
     protected _session: Session;
     protected _mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     };
     protected _columns: AbstractColumn<ColumnType>[];
     protected _logger?: BaseLogger;
-    constructor(tableName: string, session: Session, mappedServiceToDb: {
+    constructor(table: AbstractTable<TTable>, session: Session, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, logger?: BaseLogger);
     all: () => Promise<Array<ExtractModel<TTable> | undefined>>;

package/builders/highLvlBuilders/abstractRequestBuilder.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class TableRequestBuilder {
-    constructor(tableName, session, mappedServiceToDb, logger) {
+    constructor(table, session, mappedServiceToDb, logger) {
         this.all = async () => {
             const res = await this._execute();
             return res;
@@ -12,7 +12,7 @@ class TableRequestBuilder {
             return executionRes[0];
         };
         this._mappedServiceToDb = mappedServiceToDb;
-        this._tableName = tableName;
+        this._table = table;
         this._session = session;
         this._columns = Object.values(mappedServiceToDb);
         this._logger = logger;

package/builders/highLvlBuilders/deleteRequestBuilder.d.ts

@@ -1,14 +1,15 @@
-import { Column } from '../../columns/column';
+import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
 import Session from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
+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 TableRequestBuilder<TTable> {
+export default class DeleteTRB<TTable extends AbstractTable<TTable>> extends TableRequestBuilder<TTable> {
     private _filter;
-    constructor(tableName: string, session: Session, mappedServiceToDb: {
-        [name in keyof ExtractModel<TTable>]: Column<ColumnType>;
+    constructor(table: AbstractTable<TTable>, session: Session, mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, logger?: BaseLogger);
     where: (expr: Expr) => DeleteTRB<TTable>;
     execute: () => Promise<void>;

package/builders/highLvlBuilders/deleteRequestBuilder.js

@@ -6,8 +6,8 @@ const responseMapper_1 = require("../../mappers/responseMapper");
 const delete_1 = require("../lowLvlBuilders/delets/delete");
 const abstractRequestBuilder_1 = require("./abstractRequestBuilder");
 class DeleteTRB extends abstractRequestBuilder_1.default {
-    constructor(tableName, session, mappedServiceToDb, logger) {
-        super(tableName, session, mappedServiceToDb, logger);
+    constructor(table, session, mappedServiceToDb, logger) {
+        super(table, session, mappedServiceToDb, logger);
         this.where = (expr) => {
             this._filter = expr;
             return this;
@@ -16,24 +16,23 @@ class DeleteTRB extends abstractRequestBuilder_1.default {
             await this._execute();
         };
         this._execute = async () => {
-            const queryBuilder = delete_1.default.from(this._tableName);
-            if (this._filter) {
-                queryBuilder.filteredBy(this._filter);
-            }
+            const queryBuilder = delete_1.default
+                .from(this._table)
+                .filteredBy(this._filter);
             let query = '';
             try {
                 query = queryBuilder.build();
             }
             catch (e) {
-                throw new builderError_1.default(builderError_1.BuilderType.DELETE, this._tableName, this._columns, e, this._filter);
+                throw new builderError_1.default(builderError_1.BuilderType.DELETE, this._table.tableName(), this._columns, e, this._filter);
             }
             if (this._logger) {
-                this._logger.info(`Deleting from ${this._tableName} using query:\n ${query}`);
+                this._logger.info(`Deleting from ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
             if (result.isLeft()) {
                 const { reason } = result.value;
-                throw new dbErrors_1.DatabaseDeleteError(this._tableName, reason, query);
+                throw new dbErrors_1.DatabaseDeleteError(this._table.tableName(), reason, query);
             }
             else {
                 return responseMapper_1.default.map(this._mappedServiceToDb, result.value);

package/builders/highLvlBuilders/insertRequestBuilder.d.ts

@@ -4,17 +4,15 @@ import Session from '../../db/session';
 import BaseLogger from '../../logger/abstractLogger';
 import { AbstractTable } from '../../tables';
 import { ExtractModel, Indexing } from '../../tables/inferTypes';
-import UpdateExpr from '../requestBuilders/updates/updates';
 import TableRequestBuilder from './abstractRequestBuilder';
 export default class InsertTRB<TTable extends AbstractTable<TTable>> extends TableRequestBuilder<TTable> {
     private _values;
     private _onConflict;
     private _onConflictField;
-    private _table;
-    constructor(values: ExtractModel<TTable>[], tableName: string, session: Session, mappedServiceToDb: {
+    constructor(values: ExtractModel<TTable>[], session: Session, mappedServiceToDb: {
         [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
     }, table: AbstractTable<TTable>, logger?: BaseLogger);
     execute: () => Promise<void>;
-    onConflict: (callback: (table: TTable) => Indexing, expr: UpdateExpr) => InsertTRB<TTable>;
+    onConflict: (callback: (table: TTable) => Indexing, update: Partial<ExtractModel<TTable>>) => InsertTRB<TTable>;
     protected _execute: () => Promise<Array<ExtractModel<TTable> | undefined>>;
 }

package/builders/highLvlBuilders/insertRequestBuilder.js

@@ -1,61 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("..");
 const builderError_1 = require("../../errors/builderError");
 const dbErrors_1 = require("../../errors/dbErrors");
 const responseMapper_1 = require("../../mappers/responseMapper");
 const insert_1 = require("../lowLvlBuilders/inserts/insert");
 const abstractRequestBuilder_1 = require("./abstractRequestBuilder");
 class InsertTRB extends abstractRequestBuilder_1.default {
-    constructor(values, tableName, session, mappedServiceToDb, table, logger) {
-        super(tableName, session, mappedServiceToDb, logger);
+    constructor(values, session, mappedServiceToDb, table, logger) {
+        super(table, session, mappedServiceToDb, logger);
         this.execute = async () => {
             await this._execute();
         };
-        this.onConflict = (callback, expr) => {
+        this.onConflict = (callback, update) => {
             this._onConflictField = callback(this._table);
-            this._onConflict = expr;
+            const updates = [];
+            Object.entries(update).forEach(([key, value]) => {
+                const column = this._mappedServiceToDb[key];
+                updates.push(__1.set(column, value));
+            });
+            this._onConflict = __1.combine(updates);
             return this;
         };
         this._execute = async () => {
-            const queryBuilder = insert_1.default.into(this._tableName, this._columns);
             if (!this._values)
                 throw Error('Values should be provided firestly\nExample: table.values().execute()');
-            const mappedRows = [];
-            const mapper = this._mappedServiceToDb;
-            this._values.forEach((valueToInsert) => {
-                const mappedValue = {};
-                Object.entries(valueToInsert).forEach(([key, value]) => {
-                    const column = mapper[key];
-                    mappedValue[column.getColumnName()] = value;
-                });
-                mappedRows.push(mappedValue);
-            });
-            const valuesQueryBiulder = queryBuilder.values(mappedRows, mapper);
-            if (this._onConflict) {
-                valuesQueryBiulder.onConflict(this._onConflict, this._onConflictField);
-            }
-            // @TODO refactor values() part!!
+            const queryBuilder = insert_1.default
+                .into(this._table)
+                .values(this._values)
+                .onConflict(this._onConflict, this._onConflictField);
             let query = '';
             try {
                 query = queryBuilder.build();
             }
             catch (e) {
-                throw new builderError_1.default(builderError_1.BuilderType.INSERT, this._tableName, this._columns, e);
+                throw new builderError_1.default(builderError_1.BuilderType.INSERT, this._table.tableName(), this._columns, e);
             }
             if (this._logger) {
-                this._logger.info(`Inserting to ${this._tableName} using query:\n ${query}`);
+                this._logger.info(`Inserting to ${this._table.tableName()} using query:\n ${query}`);
             }
             const result = await this._session.execute(query);
             if (result.isLeft()) {
                 const { reason } = result.value;
-                throw new dbErrors_1.DatabaseInsertError(this._tableName, reason, query);
+                throw new dbErrors_1.DatabaseInsertError(this._table.tableName(), reason, query);
             }
             else {
                 return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
             }
         };
         this._values = values;
-        this._table = table;
     }
 }
 exports.default = InsertTRB;