drizzle-orm 0.10.21 → 0.10.24

package/dist/src/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/dist/src/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/dist/src/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/dist/src/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/dist/src/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/dist/src/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/dist/src/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/dist/src/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>>>;
+}

package/dist/src/builders/highLvlBuilders/insertRequestBuilder.js

@@ -0,0 +1,73 @@
+"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 });
+/* eslint-disable max-len */
+const __1 = require("..");
+const builderError_1 = __importStar(require("../../errors/builderError"));
+const responseMapper_1 = __importDefault(require("../../mappers/responseMapper"));
+const insert_1 = __importDefault(require("../lowLvlBuilders/inserts/insert"));
+const abstractRequestBuilder_1 = __importDefault(require("./abstractRequestBuilder"));
+class InsertTRB extends abstractRequestBuilder_1.default {
+    constructor(values, session, mappedServiceToDb, table, logger) {
+        super(table, session, mappedServiceToDb, logger);
+        this.execute = async () => {
+            await this._execute();
+        };
+        this.onConflict = (callback, update) => {
+            this._onConflictField = callback(this._table);
+            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 () => {
+            if (!this._values)
+                throw Error('Values should be provided firestly\nExample: table.values().execute()');
+            const queryBuilder = insert_1.default
+                .into(this._table)
+                .values(this._values)
+                .onConflict(this._onConflict, this._onConflictField);
+            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.INSERT, this._table.tableName(), this._columns, e);
+            }
+            if (this._logger) {
+                this._logger.info(`Inserting to ${this._table.tableName()} using query:\n ${query}\n${values}`);
+            }
+            const result = await this._session.execute(query, values);
+            return responseMapper_1.default.map(this._mappedServiceToDb, result);
+        };
+        this._values = values;
+    }
+}
+exports.default = InsertTRB;

package/dist/src/builders/highLvlBuilders/order.d.ts

@@ -0,0 +1,5 @@
+declare enum Order {
+    ASC = 0,
+    DESC = 1
+}
+export default Order;

package/dist/src/builders/highLvlBuilders/order.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Order;
+(function (Order) {
+    Order[Order["ASC"] = 0] = "ASC";
+    Order[Order["DESC"] = 1] = "DESC";
+})(Order || (Order = {}));
+exports.default = Order;

package/dist/src/builders/highLvlBuilders/selectRequestBuilder.d.ts

@@ -0,0 +1,47 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import DB from '../../db/db';
+import { ISession } from '../../db/session';
+import BaseLogger from '../../logger/abstractLogger';
+import { AbstractTable } from '../../tables';
+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>, 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, 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, TToColumn 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<TToColumn, 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, TTable>, to: (table: IToTable) => AbstractColumn<IToColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial>;
+    rightJoin<TColumn extends ColumnType, TToColumn 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<TToColumn, boolean, boolean>, partial?: IToPartial): SelectTRBWithJoin<TTable, IToTable, TPartial, IToPartial>;
+    fullJoin<TColumn extends ColumnType, TToColumn 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<TToColumn, 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/dist/src/builders/highLvlBuilders/selectRequestBuilder.js

@@ -0,0 +1,128 @@
+"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 __1 = require("..");
+const builderError_1 = __importStar(require("../../errors/builderError"));
+const responseMapper_1 = __importDefault(require("../../mappers/responseMapper"));
+const selectWithJoin_1 = __importDefault(require("../joinBuilders/builders/selectWithJoin"));
+const join_1 = require("../joinBuilders/join");
+const abstractRequestBuilder_1 = __importDefault(require("./abstractRequestBuilder"));
+class SelectTRB extends abstractRequestBuilder_1.default {
+    constructor(session, mappedServiceToDb, props, table, logger, partial) {
+        super(table, session, mappedServiceToDb, logger);
+        this.where = (expr) => {
+            this._filter = expr;
+            return this;
+        };
+        this.distinct = (column) => {
+            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;
+        };
+        this._execute = async () => {
+            // Select.from().filteredBy().limit().offset().orderBy().groupBy().build()
+            const queryBuilder = __1.Select
+                .from(this._table, this.__partial)
+                .distinct(this.__distinct)
+                .filteredBy(this._filter)
+                .limit(this.props.limit)
+                .offset(this.props.offset)
+                .orderBy(this.__orderBy, this.__order);
+            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.SELECT, this._table.tableName(), this._columns, e, this._filter);
+            }
+            if (this._logger) {
+                this._logger.info(`Selecting from ${this._table.tableName()} using query:\n ${query}`);
+            }
+            const result = await this._session.execute(query, values);
+            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);
+        this.__order = order;
+        return this;
+    }
+    // public groupBy(callback: (table: TTable) => Column<ColumnType, boolean, boolean>)
+    //   : SelectTRB<TTable> {
+    //   this.__groupBy = callback(this.__table);
+    //   return this;
+    // }
+    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, this.__partial, partial);
+    }
+    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, this.__partial, partial);
+    }
+    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, this.__partial, partial);
+    }
+    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, this.__partial, partial);
+    }
+}
+exports.default = SelectTRB;