drizzle-orm 0.9.1 → 0.9.2

package/builders/joinBuilders/builders/selectWithJoin.js

@@ -1,43 +1,14 @@
 "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 selectResponseWithJoin_1 = require("../responses/selectResponseWithJoin");
 const abstractJoinBuilder_1 = require("./abstractJoinBuilder");
 const selectWithTwoJoins_1 = require("./selectWithTwoJoins");
 class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
-    constructor(tableName, session, filter, join, 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._join]);
-            let query = '';
-            try {
-                query = queryBuilder.build();
-            }
-            catch (e) {
-                throw new builderError_1.default(builderError_1.BuilderType.JOINED_SELECT, this._tableName, Object.values(this._columns), e, this._filter);
-            }
-            console.log(query);
-            const parent = this._join.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);
-                return new selectResponseWithJoin_1.default(response, objects);
-            }
-        };
+    constructor(table, session, filter, join, props, orderBy, order, distinct) {
+        super(table, filter, session, props, orderBy, order, distinct);
         this._join = join;
     }
     innerJoin(table, from, to) {
@@ -46,7 +17,7 @@ class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
         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 selectWithTwoJoins_1.default(this._tableName, this._session, this._filter, this._join, join, this._columns, this._table);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct);
     }
     leftJoin(table, from, to) {
         const toTable = this._table.db.create(table);
@@ -54,7 +25,7 @@ class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
         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 selectWithTwoJoins_1.default(this._tableName, this._session, this._filter, this._join, join, this._columns, this._table);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct);
     }
     rightJoin(table, from, to) {
         const toTable = this._table.db.create(table);
@@ -62,7 +33,7 @@ class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
         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 selectWithTwoJoins_1.default(this._tableName, this._session, this._filter, this._join, join, this._columns, this._table);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct);
     }
     fullJoin(table, from, to) {
         const toTable = this._table.db.create(table);
@@ -70,7 +41,16 @@ class SelectTRBWithJoin extends abstractJoinBuilder_1.default {
         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 selectWithTwoJoins_1.default(this._tableName, this._session, this._filter, this._join, join, this._columns, this._table);
+        return new selectWithTwoJoins_1.default(this._table, this._session, this._filter, this._join, join, this._props, this._orderBy, this._order, this._distinct);
+    }
+    joins() {
+        return [this._join];
+    }
+    mapResponse(result) {
+        const parent = this._join.mappedServiceToDb;
+        const response = responseMapper_1.default.map(this._table.mapServiceToDb(), result);
+        const objects = responseMapper_1.default.map(parent, result);
+        return new selectResponseWithJoin_1.default(response, objects);
     }
 }
 exports.default = SelectTRBWithJoin;

package/builders/joinBuilders/builders/selectWithThreeJoins.d.ts

@@ -1,21 +1,23 @@
+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 SelectResponseThreeJoins from '../responses/selectResponseThreeJoins';
 import AbstractJoined from './abstractJoinBuilder';
 import SelectTRBWithFourJoins from './selectWithFourJoins';
-export default class SelectTRBWithThreeJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2, TTable3> extends AbstractJoined<TTable> {
+export default class SelectTRBWithThreeJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2, TTable3> extends AbstractJoined<TTable, SelectResponseThreeJoins<TTable, TTable1, TTable2, TTable3>> {
     private _join1;
     private _join2;
     private _join3;
-    constructor(tableName: string, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, columns: {
-        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
-    }, table: TTable);
+    constructor(table: TTable, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, join3: Join<TTable3>, 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>): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable>;
@@ -28,5 +30,6 @@ export default class SelectTRBWithThreeJoins<TTable extends AbstractTable<TTable
     fullJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
         new (db: DB): IToTable;
     }, from: (table: TTable) => AbstractColumn<TColumn>, to: (table: IToTable) => AbstractColumn<TColumn>): SelectTRBWithFourJoins<TTable, TTable1, TTable2, TTable3, IToTable>;
-    execute: () => Promise<SelectResponseThreeJoins<TTable, TTable1, TTable2, TTable3>>;
+    protected mapResponse(result: QueryResult<any>): SelectResponseThreeJoins<TTable, TTable1, TTable2, TTable3>;
+    protected joins(): Join<any>[];
 }

package/builders/joinBuilders/builders/selectWithThreeJoins.js

@@ -1,47 +1,14 @@
 "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 selectResponseThreeJoins_1 = require("../responses/selectResponseThreeJoins");
 const abstractJoinBuilder_1 = require("./abstractJoinBuilder");
 const selectWithFourJoins_1 = require("./selectWithFourJoins");
 class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
-    constructor(tableName, session, filter, join1, join2, join3, columns, table) {
-        super(filter, tableName, session, columns, table);
-        // eslint-disable-next-line max-len
-        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]);
-            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 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);
-                return new selectResponseThreeJoins_1.default(response, objects, objectsTwo, objectsThree);
-            }
-        };
+    constructor(table, session, filter, join1, join2, join3, props, orderBy, order, distinct) {
+        super(table, filter, session, props, orderBy, order, distinct);
         this._join1 = join1;
         this._join2 = join2;
         this._join3 = join3;
@@ -52,7 +19,7 @@ class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
         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 selectWithFourJoins_1.default(this._tableName, this._session, this._filter, this._join1, this._join2, this._join3, join, this._columns, this._table);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct);
     }
     leftJoin(table, from, to) {
         const toTable = this._table.db.create(table);
@@ -60,7 +27,7 @@ class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
         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 selectWithFourJoins_1.default(this._tableName, this._session, this._filter, this._join1, this._join2, this._join3, join, this._columns, this._table);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct);
     }
     rightJoin(table, from, to) {
         const toTable = this._table.db.create(table);
@@ -68,7 +35,7 @@ class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
         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 selectWithFourJoins_1.default(this._tableName, this._session, this._filter, this._join1, this._join2, this._join3, join, this._columns, this._table);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct);
     }
     fullJoin(table, from, to) {
         const toTable = this._table.db.create(table);
@@ -76,7 +43,20 @@ class SelectTRBWithThreeJoins extends abstractJoinBuilder_1.default {
         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 selectWithFourJoins_1.default(this._tableName, this._session, this._filter, this._join1, this._join2, this._join3, join, this._columns, this._table);
+        return new selectWithFourJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, this._join3, join, this._props, this._orderBy, this._order, this._distinct);
+    }
+    mapResponse(result) {
+        const parent = this._join1.mappedServiceToDb;
+        const parentTwo = this._join2.mappedServiceToDb;
+        const parentThree = this._join3.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);
+        return new selectResponseThreeJoins_1.default(response, objects, objectsTwo, objectsThree);
+    }
+    joins() {
+        return [this._join1, this._join2, this._join3];
     }
 }
 exports.default = SelectTRBWithThreeJoins;

package/builders/joinBuilders/builders/selectWithTwoJoins.d.ts

@@ -1,20 +1,22 @@
+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 SelectResponseTwoJoins from '../responses/selectResponseTwoJoins';
 import AbstractJoined from './abstractJoinBuilder';
 import SelectTRBWithThreeJoins from './selectWithThreeJoins';
-export default class SelectTRBWithTwoJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2> extends AbstractJoined<TTable> {
+export default class SelectTRBWithTwoJoins<TTable extends AbstractTable<TTable>, TTable1, TTable2> extends AbstractJoined<TTable, SelectResponseTwoJoins<TTable, TTable1, TTable2>> {
     private _join1;
     private _join2;
-    constructor(tableName: string, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, columns: {
-        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
-    }, table: TTable);
+    constructor(table: TTable, session: Session, filter: Expr, join1: Join<TTable1>, join2: Join<TTable2>, 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>): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable>;
@@ -27,5 +29,6 @@ export default class SelectTRBWithTwoJoins<TTable extends AbstractTable<TTable>,
     fullJoin<TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>>(table: {
         new (db: DB): IToTable;
     }, from: (table: TTable) => AbstractColumn<TColumn>, to: (table: IToTable) => AbstractColumn<TColumn>): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable>;
-    execute: () => Promise<SelectResponseTwoJoins<TTable, TTable1, TTable2>>;
+    protected mapResponse(result: QueryResult<any>): SelectResponseTwoJoins<TTable, TTable1, TTable2>;
+    protected joins(): Join<any>[];
 }

package/builders/joinBuilders/builders/selectWithTwoJoins.js

@@ -1,46 +1,14 @@
 "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 selectResponseTwoJoins_1 = require("../responses/selectResponseTwoJoins");
 const abstractJoinBuilder_1 = require("./abstractJoinBuilder");
 const selectWithThreeJoins_1 = require("./selectWithThreeJoins");
-// import SelectTRBWithThreeJoins from './selectWithThreeJoins';
-// eslint-disable-next-line max-len
 class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
-    constructor(tableName, session, filter, join1, join2, 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]);
-            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 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);
-                return new selectResponseTwoJoins_1.default(response, objects, objectsTwo);
-            }
-        };
+    constructor(table, session, filter, join1, join2, props, orderBy, order, distinct) {
+        super(table, filter, session, props, orderBy, order, distinct);
         this._join1 = join1;
         this._join2 = join2;
     }
@@ -50,7 +18,7 @@ class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
         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 selectWithThreeJoins_1.default(this._tableName, this._session, this._filter, this._join1, this._join2, join, this._columns, this._table);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct);
     }
     leftJoin(table, from, to) {
         const toTable = this._table.db.create(table);
@@ -58,7 +26,7 @@ class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
         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 selectWithThreeJoins_1.default(this._tableName, this._session, this._filter, this._join1, this._join2, join, this._columns, this._table);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct);
     }
     rightJoin(table, from, to) {
         const toTable = this._table.db.create(table);
@@ -66,7 +34,7 @@ class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
         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 selectWithThreeJoins_1.default(this._tableName, this._session, this._filter, this._join1, this._join2, join, this._columns, this._table);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct);
     }
     fullJoin(table, from, to) {
         const toTable = this._table.db.create(table);
@@ -74,7 +42,18 @@ class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
         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 selectWithThreeJoins_1.default(this._tableName, this._session, this._filter, this._join1, this._join2, join, this._columns, this._table);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct);
+    }
+    mapResponse(result) {
+        const parent = this._join1.mappedServiceToDb;
+        const parentTwo = this._join2.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);
+        return new selectResponseTwoJoins_1.default(response, objects, objectsTwo);
+    }
+    joins() {
+        return [this._join1, this._join2];
     }
 }
 exports.default = SelectTRBWithTwoJoins;

package/builders/joinBuilders/responses/selectResponseFiveJoins.d.ts

@@ -0,0 +1,19 @@
+import { ExtractModel } from '../../../tables/inferTypes';
+export default class SelectResponseFiveJoins<T1, T2, T3, T4, T5, T6> {
+    _t1: Array<ExtractModel<T1> | undefined>;
+    _t2: Array<ExtractModel<T2> | undefined>;
+    _t3: Array<ExtractModel<T3> | undefined>;
+    _t4: Array<ExtractModel<T4> | undefined>;
+    _t5: Array<ExtractModel<T5> | undefined>;
+    _t6: Array<ExtractModel<T6> | undefined>;
+    constructor(t1: Array<ExtractModel<T1> | undefined>, t2: Array<ExtractModel<T2> | undefined>, t3: Array<ExtractModel<T3> | undefined>, t4: Array<ExtractModel<T4> | undefined>, t5: Array<ExtractModel<T5> | undefined>, t6: Array<ExtractModel<T6> | undefined>);
+    map: <M>(imac: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined, t5: ExtractModel<T5> | undefined, t6: ExtractModel<T6> | undefined) => M) => M[];
+    foreach: (imac: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined, t5: ExtractModel<T5> | undefined, t6: ExtractModel<T6> | undefined) => void) => void;
+    group: <TOne, TMany>({ one, many, }: {
+        one: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined, t5: ExtractModel<T5> | undefined, t6: ExtractModel<T6> | undefined) => TOne;
+        many: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined, t5: ExtractModel<T5> | undefined, t6: ExtractModel<T6> | undefined) => TMany;
+    }) => {
+        one: TOne;
+        many: TMany[];
+    };
+}

package/builders/joinBuilders/responses/selectResponseFiveJoins.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SelectResponseFiveJoins {
+    constructor(t1, t2, t3, t4, t5, t6) {
+        this.map = (imac) => {
+            const objects = new Array();
+            for (let i = 0; i < this._t1.length; i += 1) {
+                objects.push(imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i], this._t6[i]));
+            }
+            return objects;
+        };
+        this.foreach = (imac) => {
+            for (let i = 0; i < this._t1.length; i += 1) {
+                imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i], this._t6[i]);
+            }
+        };
+        this.group = ({ one, many, }) => {
+            const objects = new Array();
+            for (let i = 0; i < this._t1.length; i += 1) {
+                objects.push(many(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i], this._t6[i]));
+            }
+            return {
+                one: one(this._t1[0], this._t2[0], this._t3[0], this._t4[0], this._t5[0], this._t6[0]),
+                many: objects,
+            };
+        };
+        this._t1 = t1;
+        this._t2 = t2;
+        this._t3 = t3;
+        this._t4 = t4;
+        this._t5 = t5;
+        this._t6 = t6;
+    }
+}
+exports.default = SelectResponseFiveJoins;

package/builders/joinBuilders/responses/selectResponseFourJoins.d.ts

@@ -7,4 +7,12 @@ export default class SelectResponseFourJoins<T1, T2, T3, T4, T5> {
     _t5: Array<ExtractModel<T5> | undefined>;
     constructor(t1: Array<ExtractModel<T1> | undefined>, t2: Array<ExtractModel<T2> | undefined>, t3: Array<ExtractModel<T3> | undefined>, t4: Array<ExtractModel<T4> | undefined>, t5: Array<ExtractModel<T5> | undefined>);
     map: <M>(imac: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined, t5: ExtractModel<T5> | undefined) => M) => M[];
+    foreach: (imac: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined, t5: ExtractModel<T5> | undefined) => void) => void;
+    group: <TOne, TMany>({ one, many, }: {
+        one: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined, t5: ExtractModel<T5> | undefined) => TOne;
+        many: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined, t5: ExtractModel<T5> | undefined) => TMany;
+    }) => {
+        one: TOne;
+        many: TMany[];
+    };
 }

package/builders/joinBuilders/responses/selectResponseFourJoins.js

@@ -2,10 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 class SelectResponseFourJoins {
     constructor(t1, t2, t3, t4, t5) {
-        // public groupBy = (key: keyof ExtractModel<T1>) => {
-        //   const objects = this.map((u, c, c1) => ({ u, c, c1 }));
-        //   return this._groupBy(objects, (item) => key[item]);
-        // };
         this.map = (imac) => {
             const objects = new Array();
             for (let i = 0; i < this._t1.length; i += 1) {
@@ -13,6 +9,21 @@ class SelectResponseFourJoins {
             }
             return objects;
         };
+        this.foreach = (imac) => {
+            for (let i = 0; i < this._t1.length; i += 1) {
+                imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i]);
+            }
+        };
+        this.group = ({ one, many, }) => {
+            const objects = new Array();
+            for (let i = 0; i < this._t1.length; i += 1) {
+                objects.push(many(this._t1[i], this._t2[i], this._t3[i], this._t4[i], this._t5[i]));
+            }
+            return {
+                one: one(this._t1[0], this._t2[0], this._t3[0], this._t4[0], this._t5[0]),
+                many: objects,
+            };
+        };
         this._t1 = t1;
         this._t2 = t2;
         this._t3 = t3;

package/builders/joinBuilders/responses/selectResponseThreeJoins.d.ts

@@ -6,4 +6,12 @@ export default class SelectResponseThreeJoins<T1, T2, T3, T4> {
     private _t4;
     constructor(t1: Array<ExtractModel<T1> | undefined>, t2: Array<ExtractModel<T2> | undefined>, t3: Array<ExtractModel<T3> | undefined>, t4: Array<ExtractModel<T4> | undefined>);
     map: <M>(imac: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined) => M) => M[];
+    foreach: (imac: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined) => void) => void;
+    group: <TOne, TMany>({ one, many, }: {
+        one: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined) => TOne;
+        many: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined, t4: ExtractModel<T4> | undefined) => TMany;
+    }) => {
+        one: TOne;
+        many: TMany[];
+    };
 }

package/builders/joinBuilders/responses/selectResponseThreeJoins.js

@@ -9,6 +9,21 @@ class SelectResponseThreeJoins {
             }
             return objects;
         };
+        this.foreach = (imac) => {
+            for (let i = 0; i < this._t1.length; i += 1) {
+                imac(this._t1[i], this._t2[i], this._t3[i], this._t4[i]);
+            }
+        };
+        this.group = ({ one, many, }) => {
+            const objects = new Array();
+            for (let i = 0; i < this._t1.length; i += 1) {
+                objects.push(many(this._t1[i], this._t2[i], this._t3[i], this._t4[i]));
+            }
+            return {
+                one: one(this._t1[0], this._t2[0], this._t3[0], this._t4[0]),
+                many: objects,
+            };
+        };
         this._t1 = t1;
         this._t2 = t2;
         this._t3 = t3;

package/builders/joinBuilders/responses/selectResponseTwoJoins.d.ts

@@ -5,4 +5,12 @@ export default class SelectResponseTwoJoins<T1, T2, T3> {
     private _t3;
     constructor(t1: Array<ExtractModel<T1> | undefined>, t2: Array<ExtractModel<T2> | undefined>, t3: Array<ExtractModel<T3> | undefined>);
     map: <M>(imac: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined) => M) => M[];
+    foreach: (imac: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined) => void) => void;
+    group: <TOne, TMany>({ one, many, }: {
+        one: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined) => TOne;
+        many: (t1: ExtractModel<T1> | undefined, t2: ExtractModel<T2> | undefined, t3: ExtractModel<T3> | undefined) => TMany;
+    }) => {
+        one: TOne;
+        many: TMany[];
+    };
 }

package/builders/joinBuilders/responses/selectResponseTwoJoins.js

@@ -9,6 +9,21 @@ class SelectResponseTwoJoins {
             }
             return objects;
         };
+        this.foreach = (imac) => {
+            for (let i = 0; i < this._t1.length; i += 1) {
+                imac(this._t1[i], this._t2[i], this._t3[i]);
+            }
+        };
+        this.group = ({ one, many, }) => {
+            const objects = new Array();
+            for (let i = 0; i < this._t1.length; i += 1) {
+                objects.push(many(this._t1[i], this._t2[i], this._t3[i]));
+            }
+            return {
+                one: one(this._t1[0], this._t2[0], this._t3[0]),
+                many: objects,
+            };
+        };
         this._t1 = t1;
         this._t2 = t2;
         this._t3 = t3;

package/builders/joinBuilders/responses/selectResponseWithJoin.d.ts

@@ -4,4 +4,12 @@ export default class SelectResponseJoin<TTable1, TTable2> {
     private _t2;
     constructor(t1: Array<ExtractModel<TTable1> | undefined>, t2: Array<ExtractModel<TTable2> | undefined>);
     map: <M>(imac: (t1: ExtractModel<TTable1> | undefined, t2: ExtractModel<TTable2> | undefined) => M) => M[];
+    foreach: (imac: (t1: ExtractModel<TTable1> | undefined, t2: ExtractModel<TTable2> | undefined) => void) => void;
+    group: <TOne, TMany>({ one, many, }: {
+        one: (t1: ExtractModel<TTable1> | undefined, t2: ExtractModel<TTable2> | undefined) => TOne;
+        many: (t1: ExtractModel<TTable1> | undefined, t2: ExtractModel<TTable2> | undefined) => TMany;
+    }) => {
+        one: TOne;
+        many: TMany[];
+    };
 }

package/builders/joinBuilders/responses/selectResponseWithJoin.js

@@ -9,6 +9,21 @@ class SelectResponseJoin {
             }
             return objects;
         };
+        this.foreach = (imac) => {
+            for (let i = 0; i < this._t1.length; i += 1) {
+                imac(this._t1[i], this._t2[i]);
+            }
+        };
+        this.group = ({ one, many, }) => {
+            const objects = new Array();
+            for (let i = 0; i < this._t1.length; i += 1) {
+                objects.push(many(this._t1[i], this._t2[i]));
+            }
+            return {
+                one: one(this._t1[0], this._t2[0]),
+                many: objects,
+            };
+        };
         this._t1 = t1;
         this._t2 = t2;
     }

package/builders/lowLvlBuilders/create.js

@@ -36,7 +36,7 @@ class Create {
           WHEN duplicate_object THEN null;
       END $$;`);
                     }
-                    this.columnsBuilder.push((0, ecranate_1.ecranate)(column.getColumnName()));
+                    this.columnsBuilder.push(ecranate_1.ecranate(column.getColumnName()));
                     this.columnsBuilder.push(' ');
                     this.columnsBuilder.push(column.isAutoIncrement() ? 'SERIAL' : column.getColumnType().getDbName());
                     this.columnsBuilder.push(' ');

package/builders/lowLvlBuilders/delets/delete.d.ts

@@ -1,4 +1,5 @@
+import { AbstractTable } from '../../../tables';
 import DeleteFrom from './deleteFrom';
 export default class Delete {
-    static from: (tableName: string) => DeleteFrom;
+    static from: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => DeleteFrom;
 }

package/builders/lowLvlBuilders/delets/delete.js

@@ -5,8 +5,8 @@ const deleteFrom_1 = require("./deleteFrom");
 class Delete {
 }
 exports.default = Delete;
-Delete.from = (tableName) => {
-    const aggregator = new deleteAggregator_1.default(tableName);
-    aggregator.appendFrom(tableName);
+Delete.from = (table) => {
+    const aggregator = new deleteAggregator_1.default(table);
+    aggregator.appendFrom(table.tableName());
     return new deleteFrom_1.default(aggregator);
 };

package/builders/lowLvlBuilders/inserts/insert.d.ts

@@ -1,6 +1,5 @@
-import { AbstractColumn } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
+import { AbstractTable } from '../../../tables';
 import InsertInto from './insertInto';
 export default class Insert {
-    static into: (tableName: string, columns: AbstractColumn<ColumnType>[]) => InsertInto;
+    static into: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => InsertInto;
 }

package/builders/lowLvlBuilders/inserts/insert.js

@@ -5,8 +5,8 @@ const insertInto_1 = require("./insertInto");
 class Insert {
 }
 exports.default = Insert;
-Insert.into = (tableName, columns) => {
-    const aggregator = new insertAggregator_1.default(tableName);
-    aggregator.appendFrom(tableName).appendFields(columns);
+Insert.into = (table) => {
+    const aggregator = new insertAggregator_1.default(table);
+    // aggregator.appendFrom(table.tableName());
     return new insertInto_1.default(aggregator);
 };