drizzle-orm 0.9.1 → 0.9.2

package/builders/highLvlBuilders/selectRequestBuilder.d.ts

@@ -1,4 +1,4 @@
-import { AbstractColumn, Column } from '../../columns/column';
+import { AbstractColumn } from '../../columns/column';
 import ColumnType from '../../columns/types/columnType';
 import DB from '../../db/db';
 import Session from '../../db/session';
@@ -15,15 +15,16 @@ export default class SelectTRB<TTable extends AbstractTable<TTable>> extends Tab
     private __orderBy?;
     private __groupBy?;
     private __order?;
-    private __table;
-    constructor(tableName: string, session: Session, mappedServiceToDb: {
-        [name in keyof ExtractModel<TTable>]: Column<ColumnType>;
+    private __distinct;
+    constructor(session: Session, 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: {
         new (db: DB): IToTable;
     }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithJoin<TTable, IToTable>;

package/builders/highLvlBuilders/selectRequestBuilder.js

@@ -9,55 +9,52 @@ 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(tableName, session, mappedServiceToDb, props, table, logger) {
-        super(tableName, session, mappedServiceToDb, logger);
+    constructor(session, mappedServiceToDb, props, table, logger) {
+        super(table, session, mappedServiceToDb, logger);
         this.where = (expr) => {
             this._filter = expr;
             return this;
         };
+        this.distinct = (column) => {
+            this.__distinct = column;
+            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._tableName, this._columns);
-            if (this._filter) {
-                queryBuilder.filteredBy(this._filter);
-            }
-            if (this.props.limit) {
-                queryBuilder.limit(this.props.limit);
-            }
-            if (this.props.offset) {
-                queryBuilder.offset(this.props.offset);
-            }
-            if (this.__orderBy) {
-                queryBuilder.orderBy(this.__orderBy, this.__order);
-            }
+            const queryBuilder = __1.Select
+                .from(this._table)
+                .distinct(this.__distinct)
+                .filteredBy(this._filter)
+                .limit(this.props.limit)
+                .offset(this.props.offset)
+                .orderBy(this.__orderBy, this.__order);
             let query = '';
             try {
                 query = queryBuilder.build();
             }
             catch (e) {
-                throw new builderError_1.default(builderError_1.BuilderType.SELECT, this._tableName, this._columns, e, this._filter);
+                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._tableName} using query:\n ${query}`);
+                this._logger.info(`Selecting 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.DatabaseSelectError(this._tableName, reason, query);
+                throw new dbErrors_1.DatabaseSelectError(this._table.tableName(), reason, query);
             }
             else {
                 return responseMapper_1.default.map(this._mappedServiceToDb, result.value);
             }
         };
         this.props = props;
-        this.__table = table;
     }
     orderBy(callback, order) {
-        this.__orderBy = callback(this.__table);
+        this.__orderBy = callback(this._table);
         this.__order = order;
         return this;
     }
@@ -67,36 +64,36 @@ class SelectTRB extends abstractRequestBuilder_1.default {
     //   return this;
     // }
     innerJoin(table, from, to) {
-        const toTable = this.__table.db.create(table);
-        const fromColumn = from(this.__table);
+        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._tableName, this._session, this._filter, join, this._mappedServiceToDb, this.__table);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct);
     }
     leftJoin(table, from, to) {
-        const toTable = this.__table.db.create(table);
-        const fromColumn = from(this.__table);
+        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._tableName, this._session, this._filter, join, this._mappedServiceToDb, this.__table);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct);
     }
     rightJoin(table, from, to) {
-        const toTable = this.__table.db.create(table);
-        const fromColumn = from(this.__table);
+        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._tableName, this._session, this._filter, join, this._mappedServiceToDb, this.__table);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct);
     }
     fullJoin(table, from, to) {
-        const toTable = this.__table.db.create(table);
-        const fromColumn = from(this.__table);
+        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._tableName, this._session, this._filter, join, this._mappedServiceToDb, this.__table);
+        return new selectWithJoin_1.default(this._table, this._session, this._filter, join, this.props, this.__orderBy, this.__order, this.__distinct);
     }
 }
 exports.default = SelectTRB;

package/builders/highLvlBuilders/updateRequestBuilder.d.ts

@@ -1,16 +1,17 @@
-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 UpdateTRB<TTable> extends TableRequestBuilder<TTable> {
+export default class UpdateTRB<TTable extends AbstractTable<TTable>> extends TableRequestBuilder<TTable> {
     private _filter;
     private _update;
     private _objToUpdate;
-    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) => UpdateTRB<TTable>;
     set: (expr: Partial<ExtractModel<TTable>>) => UpdateTRB<TTable>;

package/builders/highLvlBuilders/updateRequestBuilder.js

@@ -7,8 +7,8 @@ const update_1 = require("../lowLvlBuilders/updates/update");
 const static_1 = require("../requestBuilders/updates/static");
 const abstractRequestBuilder_1 = require("./abstractRequestBuilder");
 class UpdateTRB 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;
@@ -17,9 +17,9 @@ class UpdateTRB extends abstractRequestBuilder_1.default {
             const updates = [];
             Object.entries(expr).forEach(([key, value]) => {
                 const column = this._mappedServiceToDb[key];
-                updates.push((0, static_1.set)(column, value));
+                updates.push(static_1.set(column, value));
             });
-            this._update = (0, static_1.combine)(updates);
+            this._update = static_1.combine(updates);
             return this;
         };
         this.execute = async () => {
@@ -28,22 +28,22 @@ class UpdateTRB extends abstractRequestBuilder_1.default {
         this._execute = async () => {
             let query = '';
             try {
-                query = update_1.default.in(this._tableName)
-                    .columns(this._columns)
+                query = update_1.default.in(this._table)
+                    .columns()
                     .set(this._update)
                     .filteredBy(this._filter)
                     .build();
             }
             catch (e) {
-                throw new builderError_1.default(builderError_1.BuilderType.UPDATE, this._tableName, this._columns, e, this._filter);
+                throw new builderError_1.default(builderError_1.BuilderType.UPDATE, this._table.tableName(), this._columns, e, this._filter);
             }
             if (this._logger) {
-                this._logger.info(`Updating ${this._tableName} using query:\n ${query}`);
+                this._logger.info(`Updating ${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.DatabaseUpdateError(this._tableName, reason, query);
+                throw new dbErrors_1.DatabaseUpdateError(this._table.tableName(), reason, query);
             }
             else {
                 return responseMapper_1.default.map(this._mappedServiceToDb, result.value);

package/builders/index.d.ts

@@ -15,4 +15,4 @@ export { default as Insert } from './lowLvlBuilders/inserts/insert';
 export { default as Select } from './lowLvlBuilders/selects/select';
 export { default as Update } from './lowLvlBuilders/updates/update';
 export { set, combine } from './requestBuilders/updates/static';
-export { eq, inArray as in, and, or, like, greater, greaterEq, less, lessEq, } from './requestBuilders/where/static';
+export { eq, inArray as in, and, or, like, greater, greaterEq, less, lessEq, raw, } from './requestBuilders/where/static';

package/builders/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lessEq = exports.less = exports.greaterEq = exports.greater = exports.like = exports.or = exports.and = exports.in = exports.eq = exports.combine = exports.set = exports.Update = exports.Select = exports.Insert = exports.Delete = exports.Create = exports.SelectResponseJoin = exports.SelectResponseTwoJoins = exports.SelectTRBWithTwoJoins = exports.SelectTRBWithJoin = exports.Join = exports.JoinWith = exports.to = exports.UpdateTRB = exports.SelectTRB = exports.InsertTRB = exports.DeleteTRB = void 0;
+exports.raw = exports.lessEq = exports.less = exports.greaterEq = exports.greater = exports.like = exports.or = exports.and = exports.in = exports.eq = exports.combine = exports.set = exports.Update = exports.Select = exports.Insert = exports.Delete = exports.Create = exports.SelectResponseJoin = exports.SelectResponseTwoJoins = exports.SelectTRBWithTwoJoins = exports.SelectTRBWithJoin = exports.Join = exports.JoinWith = exports.to = exports.UpdateTRB = exports.SelectTRB = exports.InsertTRB = exports.DeleteTRB = void 0;
 /* eslint-disable import/no-cycle */
 var deleteRequestBuilder_1 = require("./highLvlBuilders/deleteRequestBuilder");
 Object.defineProperty(exports, "DeleteTRB", { enumerable: true, get: function () { return deleteRequestBuilder_1.default; } });
@@ -47,3 +47,4 @@ Object.defineProperty(exports, "greater", { enumerable: true, get: function () {
 Object.defineProperty(exports, "greaterEq", { enumerable: true, get: function () { return static_3.greaterEq; } });
 Object.defineProperty(exports, "less", { enumerable: true, get: function () { return static_3.less; } });
 Object.defineProperty(exports, "lessEq", { enumerable: true, get: function () { return static_3.lessEq; } });
+Object.defineProperty(exports, "raw", { enumerable: true, get: function () { return static_3.raw; } });

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

@@ -1,18 +1,27 @@
+import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import Session from '../../../db/session';
 import { AbstractTable } from '../../../tables';
-import { ExtractModel } from '../../../tables/inferTypes';
+import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
-export default abstract class AbstractJoined<TTable extends AbstractTable<TTable>> {
-    protected _tableName: string;
+import Join from '../join';
+export default abstract class AbstractJoined<TTable extends AbstractTable<TTable>, TRes> {
+    protected _table: TTable;
     protected _session: Session;
     protected _filter: Expr;
-    protected _table: TTable;
-    protected _columns: {
-        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
+    protected _distinct?: AbstractColumn<ColumnType, boolean, boolean>;
+    protected _props: {
+        limit?: number;
+        offset?: number;
     };
-    constructor(filter: Expr, tableName: string, session: Session, columns: {
-        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
-    }, table: TTable);
+    protected _orderBy?: AbstractColumn<ColumnType, boolean, boolean>;
+    protected _order?: Order;
+    constructor(table: TTable, filter: Expr, session: Session, props: {
+        limit?: number;
+        offset?: number;
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);
+    execute: () => Promise<TRes>;
+    protected abstract mapResponse(result: QueryResult<any>): TRes;
+    protected abstract joins(): Array<Join<any>>;
 }

package/builders/joinBuilders/builders/abstractJoinBuilder.js

@@ -1,12 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const builderError_1 = require("../../../errors/builderError");
+const dbErrors_1 = require("../../../errors/dbErrors");
+const select_1 = require("../../lowLvlBuilders/selects/select");
 class AbstractJoined {
-    constructor(filter, tableName, session, columns, table) {
-        this._tableName = tableName;
+    constructor(table, filter, session, props, orderBy, order, distinct) {
+        this.execute = async () => {
+            const queryBuilder = select_1.default
+                .from(this._table)
+                .distinct(this._distinct)
+                .joined(this.joins())
+                .limit(this._props.limit)
+                .offset(this._props.offset)
+                .filteredBy(this._filter)
+                .orderBy(this._orderBy, this._order);
+            let query = '';
+            try {
+                query = queryBuilder.build();
+            }
+            catch (e) {
+                throw new builderError_1.default(builderError_1.BuilderType.JOINED_SELECT, this._table.tableName(), Object.values(this._table.mapServiceToDb()), e, this._filter);
+            }
+            const result = await this._session.execute(query);
+            if (result.isLeft()) {
+                const { reason } = result.value;
+                throw new dbErrors_1.DatabaseSelectError(this._table.tableName(), reason, query);
+            }
+            else {
+                return this.mapResponse(result.value);
+            }
+        };
+        this._table = table;
         this._session = session;
         this._filter = filter;
-        this._columns = columns;
-        this._table = table;
+        this._props = props;
+        this._order = order;
+        this._orderBy = orderBy;
+        this._distinct = distinct;
     }
 }
 exports.default = AbstractJoined;

package/builders/joinBuilders/builders/selectWithFiveJoins.d.ts

@@ -0,0 +1,23 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
+import Session from '../../../db/session';
+import { AbstractTable } from '../../../tables';
+import Order from '../../highLvlBuilders/order';
+import Expr from '../../requestBuilders/where/where';
+import Join from '../join';
+import SelectResponseFiveJoins from '../responses/selectResponseFiveJoins';
+import AbstractJoined from './abstractJoinBuilder';
+export default class SelectTRBWithFiveJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2, TTable3, TTable4, TTable5> extends AbstractJoined<TTable, SelectResponseFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, TTable5>> {
+    private _join1;
+    private _join2;
+    private _join3;
+    private _join4;
+    private _join5;
+    constructor(table: TTable, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, join5: Join<TTable5>, props: {
+        limit?: number;
+        offset?: number;
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);
+    protected joins(): Join<any>[];
+    protected mapResponse(result: QueryResult<any>): SelectResponseFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, TTable5>;
+}

package/builders/joinBuilders/builders/selectWithFiveJoins.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const responseMapper_1 = require("../../../mappers/responseMapper");
+const selectResponseFiveJoins_1 = require("../responses/selectResponseFiveJoins");
+const abstractJoinBuilder_1 = require("./abstractJoinBuilder");
+class SelectTRBWithFiveJoins extends abstractJoinBuilder_1.default {
+    constructor(table, session, filter, join1, join2, join3, join4, join5, props, orderBy, order, distinct) {
+        super(table, filter, session, props, orderBy, order, distinct);
+        this._join1 = join1;
+        this._join2 = join2;
+        this._join3 = join3;
+        this._join4 = join4;
+        this._join5 = join5;
+    }
+    joins() {
+        return [this._join1, this._join2, this._join3, this._join4, this._join5];
+    }
+    mapResponse(result) {
+        const parent = this._join1.mappedServiceToDb;
+        const parentTwo = this._join2.mappedServiceToDb;
+        const parentThree = this._join3.mappedServiceToDb;
+        const parentFour = this._join4.mappedServiceToDb;
+        const parentFive = this._join5.mappedServiceToDb;
+        const response = responseMapper_1.default.map(this._table.mapServiceToDb(), result);
+        const objects = responseMapper_1.default.map(parent, result);
+        const objectsTwo = responseMapper_1.default.map(parentTwo, result);
+        const objectsThree = responseMapper_1.default.map(parentThree, result);
+        const objectsFour = responseMapper_1.default.map(parentFour, result);
+        const objectsFive = responseMapper_1.default.map(parentFive, result);
+        return new selectResponseFiveJoins_1.default(response, objects, objectsTwo, objectsThree, objectsFour, objectsFive);
+    }
+}
+exports.default = SelectTRBWithFiveJoins;

package/builders/joinBuilders/builders/selectWithFourJoins.d.ts

@@ -1,19 +1,36 @@
+import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
+import DB from '../../../db/db';
 import Session from '../../../db/session';
 import { AbstractTable } from '../../../tables';
-import { ExtractModel } from '../../../tables/inferTypes';
+import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
 import Join from '../join';
 import SelectResponseFourJoins from '../responses/selectResponseFourJoins';
 import AbstractJoined from './abstractJoinBuilder';
-export default class SelectTRBWithFourJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2, TTable3, TTable4> extends AbstractJoined<TTable> {
+import SelectTRBWithFiveJoins from './selectWithFiveJoins';
+export default class SelectTRBWithFourJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2, TTable3, TTable4> extends AbstractJoined<TTable, SelectResponseFourJoins<TTable, TTable1, TTable2, TTable3, TTable4>> {
     private _join1;
     private _join2;
     private _join3;
     private _join4;
-    constructor(tableName: string, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, columns: {
-        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
-    }, table: TTable);
-    execute: () => Promise<SelectResponseFourJoins<TTable, TTable1, TTable2, TTable3, TTable4>>;
+    constructor(table: TTable, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, join4: Join<TTable4>, props: {
+        limit?: number;
+        offset?: number;
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);
+    innerJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+        new (db: DB): IToTable;
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable>;
+    leftJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+        new (db: DB): IToTable;
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable>;
+    rightJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+        new (db: DB): IToTable;
+    }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable>;
+    fullJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
+        new (db: DB): IToTable;
+    }, from: (table: TTable) => AbstractColumn<TColumn>, to: (table: IToTable) => AbstractColumn<TColumn>): SelectTRBWithFiveJoins<TTable, TTable1, TTable2, TTable3, TTable4, IToTable>;
+    protected joins(): Join<any>[];
+    protected mapResponse(result: QueryResult<any>): SelectResponseFourJoins<TTable, TTable1, TTable2, TTable3, TTable4>;
 }

package/builders/joinBuilders/builders/selectWithFourJoins.js

@@ -1,49 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const builderError_1 = require("../../../errors/builderError");
-const dbErrors_1 = require("../../../errors/dbErrors");
 const responseMapper_1 = require("../../../mappers/responseMapper");
-const select_1 = require("../../lowLvlBuilders/selects/select");
+const join_1 = require("../join");
+const joinWith_1 = require("../joinWith");
 const selectResponseFourJoins_1 = require("../responses/selectResponseFourJoins");
 const abstractJoinBuilder_1 = require("./abstractJoinBuilder");
+const selectWithFiveJoins_1 = require("./selectWithFiveJoins");
 class SelectTRBWithFourJoins extends abstractJoinBuilder_1.default {
-    constructor(tableName, session, filter, join1, join2, join3, join4, columns, table) {
-        super(filter, tableName, session, columns, table);
-        this.execute = async () => {
-            const queryBuilder = select_1.default.from(this._tableName, Object.values(this._columns));
-            if (this._filter) {
-                queryBuilder.filteredBy(this._filter);
-            }
-            queryBuilder.joined([this._join1, this._join2, this._join3, this._join4]);
-            let query = '';
-            try {
-                query = queryBuilder.build();
-            }
-            catch (e) {
-                throw new builderError_1.default(builderError_1.BuilderType.TWO_JOINED_SELECT, this._tableName, Object.values(this._columns), e, this._filter);
-            }
-            const parent = this._join1.mappedServiceToDb;
-            const parentTwo = this._join2.mappedServiceToDb;
-            const parentThree = this._join3.mappedServiceToDb;
-            const parentFour = this._join4.mappedServiceToDb;
-            const result = await this._session.execute(query);
-            if (result.isLeft()) {
-                const { reason } = result.value;
-                throw new dbErrors_1.DatabaseSelectError(this._tableName, reason, query);
-            }
-            else {
-                const response = responseMapper_1.default.map(this._columns, result.value);
-                const objects = responseMapper_1.default.map(parent, result.value);
-                const objectsTwo = responseMapper_1.default.map(parentTwo, result.value);
-                const objectsThree = responseMapper_1.default.map(parentThree, result.value);
-                const objectsFour = responseMapper_1.default.map(parentFour, result.value);
-                return new selectResponseFourJoins_1.default(response, objects, objectsTwo, objectsThree, objectsFour);
-            }
-        };
+    constructor(table, session, filter, join1, join2, join3, join4, props, orderBy, order, distinct) {
+        super(table, filter, session, props, orderBy, order, distinct);
         this._join1 = join1;
         this._join2 = join2;
         this._join3 = join3;
         this._join4 = join4;
     }
+    innerJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        const toColumn = to(toTable);
+        const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
+            .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.INNER_JOIN);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct);
+    }
+    leftJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        const toColumn = to(toTable);
+        const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
+            .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.LEFT_JOIN);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct);
+    }
+    rightJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        const toColumn = to(toTable);
+        const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
+            .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.RIGHT_JOIN);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct);
+    }
+    fullJoin(table, from, to) {
+        const toTable = this._table.db.create(table);
+        const fromColumn = from(this._table);
+        const toColumn = to(toTable);
+        const join = new joinWith_1.default(toTable.tableName(), toTable.mapServiceToDb())
+            .columns(fromColumn, toColumn).joinStrategy(join_1.JoinStrategy.FULL_JOIN);
+        return new selectWithFiveJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, this._join4, join, this._props, this._orderBy, this._order, this._distinct);
+    }
+    joins() {
+        return [this._join1, this._join2, this._join3, this._join4];
+    }
+    mapResponse(result) {
+        const parent = this._join1.mappedServiceToDb;
+        const parentTwo = this._join2.mappedServiceToDb;
+        const parentThree = this._join3.mappedServiceToDb;
+        const parentFour = this._join4.mappedServiceToDb;
+        const response = responseMapper_1.default.map(this._table.mapServiceToDb(), result);
+        const objects = responseMapper_1.default.map(parent, result);
+        const objectsTwo = responseMapper_1.default.map(parentTwo, result);
+        const objectsThree = responseMapper_1.default.map(parentThree, result);
+        const objectsFour = responseMapper_1.default.map(parentFour, result);
+        return new selectResponseFourJoins_1.default(response, objects, objectsTwo, objectsThree, objectsFour);
+    }
 }
 exports.default = SelectTRBWithFourJoins;

package/builders/joinBuilders/builders/selectWithJoin.d.ts

@@ -1,19 +1,21 @@
+import { QueryResult } from 'pg';
 import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import DB from '../../../db/db';
 import Session from '../../../db/session';
 import AbstractTable from '../../../tables/abstractTable';
-import { ExtractModel } from '../../../tables/inferTypes';
+import Order from '../../highLvlBuilders/order';
 import Expr from '../../requestBuilders/where/where';
 import Join from '../join';
 import SelectResponseJoin from '../responses/selectResponseWithJoin';
 import AbstractJoined from './abstractJoinBuilder';
 import SelectTRBWithTwoJoins from './selectWithTwoJoins';
-export default class SelectTRBWithJoin<TTable extends AbstractTable<TTable>, TTable1> extends AbstractJoined<TTable> {
+export default class SelectTRBWithJoin<TTable extends AbstractTable<TTable>, TTable1> extends AbstractJoined<TTable, SelectResponseJoin<TTable, TTable1>> {
     private _join;
-    constructor(tableName: string, session: Session, filter: Expr, join: Join<TTable1>, columns: {
-        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
-    }, table: TTable);
+    constructor(table: TTable, session: Session, filter: Expr, join: Join<TTable1>, props: {
+        limit?: number;
+        offset?: number;
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>);
     innerJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
         new (db: DB): IToTable;
     }, from: (table: TTable) => AbstractColumn<TColumn, boolean, boolean>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean>): SelectTRBWithTwoJoins<TTable, TTable1, IToTable>;
@@ -26,5 +28,6 @@ export default class SelectTRBWithJoin<TTable extends AbstractTable<TTable>, TTa
     fullJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
         new (db: DB): IToTable;
     }, from: (table: TTable) => AbstractColumn<TColumn>, to: (table: IToTable) => AbstractColumn<TColumn>): SelectTRBWithTwoJoins<TTable, TTable1, IToTable>;
-    execute: () => Promise<SelectResponseJoin<TTable, TTable1>>;
+    protected joins(): Join<any>[];
+    protected mapResponse(result: QueryResult<any>): SelectResponseJoin<TTable, TTable1>;
 }