drizzle-orm 0.10.32 → 0.10.33

package/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[];
+}

package/builders/aggregators/abstractAggregator.js

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

package/builders/aggregators/deleteAggregator.d.ts

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

package/builders/aggregators/deleteAggregator.js

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

package/builders/aggregators/insertAggregator.d.ts

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

package/builders/aggregators/insertAggregator.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-loop-func */
+const column_1 = require("../../columns/column");
+const abstractAggregator_1 = __importDefault(require("./abstractAggregator"));
+class InsertAggregator extends abstractAggregator_1.default {
+    constructor(table) {
+        super(table);
+        this._onConflict = [];
+        this._columns = [];
+        this._query = [];
+        this._values = [];
+        this._from = [];
+        this._insert = ['INSERT INTO'];
+        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.getColumnName());
+                this._columns.push('"');
+                if (i < columns.length - 1) {
+                    this._columns.push(', ');
+                }
+            }
+        };
+        this.appendValues = (values) => {
+            // @TODO Check if values not empty
+            const mapper = this._table.mapServiceToDb();
+            let position = 0;
+            for (let i = 0; i < values.length; i += 1) {
+                const value = values[i];
+                this._query.push('(');
+                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) {
+                            position += 1;
+                            this._query.push(`$${position}`);
+                            this._values.push(column.getColumnType().insertStrategy(valueToInsert));
+                        }
+                        else {
+                            this._query.push('null');
+                        }
+                    }
+                    else {
+                        this._query.push('DEFAULT');
+                    }
+                    if (index < entries.length - 1) {
+                        this._query.push(', ');
+                    }
+                });
+                if (i < values.length - 1) {
+                    this._query.push('),\n');
+                }
+                else {
+                    this._query.push(')\n');
+                }
+            }
+        };
+        this.appendOnConflict = (column, updates) => {
+            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) {
+                    const currentPointerPosition = this._values.length > 0
+                        ? this._values.length + 1 : undefined;
+                    const updatesQuery = updates.toQuery(currentPointerPosition);
+                    this._onConflict.push('DO UPDATE\n');
+                    this._onConflict.push(`SET ${updatesQuery.query}`);
+                    this._values.push(...updatesQuery.values);
+                }
+                else {
+                    this._onConflict.push('DO NOTHING\n');
+                }
+            }
+            return this;
+        };
+        this.buildQuery = () => {
+            this._insert.push(this._from.join(''));
+            this._insert.push(' (');
+            this._insert.push(this._columns.join(''));
+            this._insert.push(') ');
+            this._insert.push('VALUES\n');
+            this._insert.push(this._query.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(''));
+            return { query: this._insert.join(''), values: this._values };
+        };
+        this._from.push(' ');
+        this._from.push(table.tableName());
+    }
+}
+exports.default = InsertAggregator;

package/builders/aggregators/selectAggregator.d.ts

@@ -0,0 +1,39 @@
+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';
+import Aggregator from './abstractAggregator';
+export default class SelectAggregator extends Aggregator {
+    private _from;
+    private _filters;
+    private _select;
+    private _join;
+    private _limit;
+    private _offset;
+    private _distinct;
+    private _orderBy;
+    private _values;
+    private _joinCache;
+    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, any> | undefined, order?: Order | undefined) => SelectAggregator;
+    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined) => SelectAggregator;
+    appendFrom: (tableName: string) => SelectAggregator;
+    join: (joins: {
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        } | undefined;
+        id?: number | undefined;
+    }[]) => SelectAggregator;
+    buildQuery: () => {
+        query: string;
+        values: Array<any>;
+    };
+}

package/builders/aggregators/selectAggregator.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ecranate_1 = require("../../utils/ecranate");
+const order_1 = __importDefault(require("../highLvlBuilders/order"));
+const abstractAggregator_1 = __importDefault(require("./abstractAggregator"));
+class SelectAggregator extends abstractAggregator_1.default {
+    // 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'];
+        this._join = [];
+        this._limit = [];
+        this._offset = [];
+        this._distinct = [];
+        // private _groupBy: Array<string> = [];
+        this._orderBy = [];
+        this._values = [];
+        this._joinCache = {};
+        this.filters = (filters) => {
+            if (filters) {
+                const queryBuilder = filters.toQuery(1, this._joinCache);
+                this._filters.push('WHERE ');
+                this._filters.push(queryBuilder.query);
+                this._values = queryBuilder.values;
+            }
+            return this;
+        };
+        this.limit = (limit) => {
+            if (limit) {
+                this._limit.push('LIMIT ');
+                this._limit.push(limit.toString());
+            }
+            return this;
+        };
+        this.offset = (offset) => {
+            if (offset) {
+                this._offset.push('OFFSET ');
+                this._offset.push(offset.toString());
+            }
+            return this;
+        };
+        this.orderBy = (column, order) => {
+            if (column !== null && column !== undefined) {
+                this._orderBy.push('ORDER BY ');
+                const columnParent = this._joinCache[column.getParent().tableName()] ? this._joinCache[column.getParent().tableName()] : column.getParent().tableName();
+                this._orderBy.push(`${columnParent}.${ecranate_1.ecranate(column.getColumnName())} `);
+                this._orderBy.push(order_1.default[order]);
+            }
+            return this;
+        };
+        this.distinct = (column) => {
+            if (column) {
+                this._distinct.push(` DISTINCT ON(${column.getParent().tableName()}.${ecranate_1.ecranate(column.getColumnName())}) `);
+            }
+            return this;
+        };
+        this.appendFrom = (tableName) => {
+            this._from.push('FROM ');
+            this._from.push(tableName);
+            // this._from.push(`${tableName} AS ${tableName}_0`);
+            this._joinCache[tableName] = tableName;
+            return this;
+        };
+        // Add select generator for second table also
+        this.join = (joins) => {
+            // const cache: {[tableName: string]: string} = {};
+            joins.forEach((joinObject) => {
+                if (joinObject) {
+                    const tableFrom = joinObject.join.fromColumn.getParentName();
+                    const tableTo = joinObject.join.toColumn.getParentName();
+                    const { type } = joinObject.join;
+                    let fromAlias = '';
+                    if (this._joinCache[tableFrom]) {
+                        fromAlias = this._joinCache[tableFrom];
+                    }
+                    else {
+                        fromAlias = `${tableFrom}${joinObject.id ? `_${joinObject.id}` : ''}`;
+                        this._joinCache[tableFrom] = fromAlias;
+                    }
+                    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._joinCache[tableTo] = `${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`;
+                    this._join.push('\n');
+                    this._join.push('ON ');
+                    this._join.push(fromAlias);
+                    // if (this._joinCache[tableFrom]) {
+                    //   this._join.push(this._joinCache[tableFrom]);
+                    // } else {
+                    //   this._join.push(tableFrom);
+                    //   this._joinCache[tableFrom] = `${tableFrom}${joinObject.id ? `_${joinObject.id}` : ''}`;
+                    // }
+                    this._join.push('.');
+                    this._join.push(joinObject.join.fromColumn.getColumnName());
+                    this._join.push(' = ');
+                    this._join.push(`${tableTo}${joinObject.id ? `_${joinObject.id}` : ''}`);
+                    // this._join.push(toAlias);
+                    this._join.push('.');
+                    this._join.push(joinObject.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(''));
+            this._select.push('\n');
+            this._select.push(this._join.join(''));
+            if (this._join.length > 0) {
+                this._select.push('\n');
+            }
+            this._select.push(this._filters.join(''));
+            this._select.push('\n');
+            this._select.push(this._orderBy.join(''));
+            this._select.push('\n');
+            this._select.push(this._limit.join(''));
+            this._select.push('\n');
+            this._select.push(this._offset.join(''));
+            return { query: this._select.join(''), values: this._values };
+        };
+    }
+}
+exports.default = SelectAggregator;

package/builders/aggregators/updateAggregator.d.ts

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

package/builders/aggregators/updateAggregator.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractAggregator_1 = __importDefault(require("./abstractAggregator"));
+class UpdateAggregator extends abstractAggregator_1.default {
+    constructor(table) {
+        super(table);
+        this._updates = [];
+        this._filters = [];
+        this._from = [];
+        this._values = [];
+        this._update = ['UPDATE'];
+        this.where = (filters) => {
+            if (filters) {
+                const currentPointerPosition = this._values.length > 0 ? this._values.length + 1 : undefined;
+                const filterQuery = filters.toQuery(currentPointerPosition);
+                this._filters.push('WHERE ');
+                this._filters.push(filterQuery.query);
+                this._values.push(...filterQuery.values);
+            }
+            return this;
+        };
+        this.appendFrom = (tableName) => {
+            this._from.push(' ');
+            this._from.push(tableName);
+            return this;
+        };
+        this.set = (updates) => {
+            const setQuery = updates.toQuery();
+            this._updates.push(`\nSET ${setQuery.query}`);
+            this._values.push(...setQuery.values);
+            return this;
+        };
+        this.buildQuery = () => {
+            this._update.push(this._from.join(''));
+            this._update.push('\n');
+            this._update.push(this._updates.join(''));
+            this._update.push('\n');
+            this._update.push(this._filters.join(''));
+            this._update.push('\n');
+            this._update.push('RETURNING');
+            this._update.push('\n');
+            this._update.push(this._fields.join(''));
+            return { query: this._update.join(''), values: this._values };
+        };
+    }
+}
+exports.default = UpdateAggregator;

package/builders/highLvlBuilders/abstractRequestBuilder.d.ts

@@ -0,0 +1,27 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+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>, TPartial extends {
+    [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>;
+} = {}> {
+    protected _table: TTable;
+    protected _session: ISession;
+    protected _mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
+    };
+    protected _columns: AbstractColumn<ColumnType>[];
+    protected _logger?: BaseLogger;
+    constructor(table: AbstractTable<TTable>, session: ISession, mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
+    }, logger?: BaseLogger);
+    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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TableRequestBuilder {
+    constructor(table, session, mappedServiceToDb, logger) {
+        this.all = async () => {
+            const res = await this._execute();
+            return res;
+        };
+        /**
+         * 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();
+            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;
+        this._session = session;
+        this._columns = Object.values(mappedServiceToDb);
+        this._logger = logger;
+    }
+}
+exports.default = TableRequestBuilder;

package/builders/highLvlBuilders/deleteRequestBuilder.d.ts

@@ -0,0 +1,19 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { ISession } 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 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<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>>;
+}

package/builders/highLvlBuilders/deleteRequestBuilder.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const builderError_1 = __importStar(require("../../errors/builderError"));
+const responseMapper_1 = __importDefault(require("../../mappers/responseMapper"));
+const delete_1 = __importDefault(require("../lowLvlBuilders/delets/delete"));
+const abstractRequestBuilder_1 = __importDefault(require("./abstractRequestBuilder"));
+class DeleteTRB extends abstractRequestBuilder_1.default {
+    constructor(table, session, mappedServiceToDb, logger) {
+        super(table, session, mappedServiceToDb, logger);
+        this.where = (expr) => {
+            this._filter = expr;
+            return this;
+        };
+        this.execute = async () => {
+            await this._execute();
+        };
+        this._execute = async () => {
+            const queryBuilder = delete_1.default
+                .from(this._table)
+                .filteredBy(this._filter);
+            let query = '';
+            let values = [];
+            try {
+                const builderResult = queryBuilder.build();
+                query = builderResult.query;
+                values = builderResult.values;
+            }
+            catch (e) {
+                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._table.tableName()} using query:\n ${query}`);
+            }
+            const result = await this._session.execute(query, values);
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
+        };
+    }
+}
+exports.default = DeleteTRB;

package/builders/highLvlBuilders/insertRequestBuilder.d.ts

@@ -0,0 +1,20 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { ISession } from '../../db/session';
+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>, TPartial extends {
+    [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, TTable>;
+} = {}> extends TableRequestBuilder<TTable, TPartial> {
+    private _values;
+    private _onConflict;
+    private _onConflictField;
+    constructor(values: ExtractModel<TTable>[], session: ISession, mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
+    }, table: AbstractTable<TTable>, logger?: BaseLogger);
+    execute: () => Promise<void>;
+    onConflict: (callback: (table: TTable) => Indexing, update: Partial<ExtractModel<TTable>>) => InsertTRB<TTable>;
+    protected _execute: () => Promise<Array<[keyof TPartial] extends [never] ? ExtractModel<TTable> : ExtractModel<TPartial>>>;
+}