drizzle-orm 0.9.0 → 0.9.4

package/builders/joinBuilders/builders/selectWithThreeJoins.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const responseMapper_1 = require("../../../mappers/responseMapper");
+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(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;
+    }
+    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 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);
+        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 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);
+        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 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);
+        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 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

@@ -0,0 +1,34 @@
+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 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, SelectResponseTwoJoins<TTable, TTable1, TTable2>> {
+    private _join1;
+    private _join2;
+    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>;
+    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>): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, 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>): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable>;
+    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>;
+    protected mapResponse(result: QueryResult<any>): SelectResponseTwoJoins<TTable, TTable1, TTable2>;
+    protected joins(): Join<any>[];
+}

package/builders/joinBuilders/builders/selectWithTwoJoins.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const responseMapper_1 = require("../../../mappers/responseMapper");
+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");
+class SelectTRBWithTwoJoins extends abstractJoinBuilder_1.default {
+    constructor(table, session, filter, join1, join2, props, orderBy, order, distinct) {
+        super(table, filter, session, props, orderBy, order, distinct);
+        this._join1 = join1;
+        this._join2 = join2;
+    }
+    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 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);
+        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 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);
+        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 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);
+        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 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/join.d.ts

@@ -0,0 +1,23 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { ExtractModel } from '../../tables/inferTypes';
+export default class Join<TTable> {
+    fromColumn: AbstractColumn<ColumnType, boolean, boolean>;
+    toColumn: AbstractColumn<ColumnType, boolean, boolean>;
+    joinTableName: string;
+    mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
+    };
+    type: JoinStrategy;
+    constructor(joinTableName: string, fromColumn: AbstractColumn<ColumnType, boolean, boolean>, toColumn: AbstractColumn<ColumnType, boolean, boolean>, mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<ColumnType>;
+    });
+    joinStrategy: (type: JoinStrategy) => Join<TTable>;
+    columns: (fromColumn: AbstractColumn<ColumnType>, toColumn: AbstractColumn<ColumnType>) => Join<TTable>;
+}
+export declare enum JoinStrategy {
+    INNER_JOIN = "INNER JOIN",
+    LEFT_JOIN = "LEFT JOIN",
+    RIGHT_JOIN = "RIGHT JOIN",
+    FULL_JOIN = "FULL JOIN"
+}

package/builders/joinBuilders/join.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinStrategy = void 0;
+class Join {
+    constructor(joinTableName, fromColumn, toColumn, mappedServiceToDb) {
+        this.joinStrategy = (type) => {
+            this.type = type;
+            return this;
+        };
+        this.columns = (fromColumn, toColumn) => {
+            this.toColumn = toColumn;
+            this.fromColumn = fromColumn;
+            return this;
+        };
+        this.joinTableName = joinTableName;
+        this.toColumn = toColumn;
+        this.fromColumn = fromColumn;
+        this.mappedServiceToDb = mappedServiceToDb;
+    }
+}
+exports.default = Join;
+var JoinStrategy;
+(function (JoinStrategy) {
+    JoinStrategy["INNER_JOIN"] = "INNER JOIN";
+    JoinStrategy["LEFT_JOIN"] = "LEFT JOIN";
+    JoinStrategy["RIGHT_JOIN"] = "RIGHT JOIN";
+    JoinStrategy["FULL_JOIN"] = "FULL JOIN";
+})(JoinStrategy = exports.JoinStrategy || (exports.JoinStrategy = {}));

package/builders/joinBuilders/joinWith.d.ts

@@ -0,0 +1,14 @@
+import { AbstractColumn } from '../../columns/column';
+import ColumnType from '../../columns/types/columnType';
+import { ExtractModel } from '../../tables/inferTypes';
+import Join from './join';
+export default class JoinWith<TColumn extends ColumnType, TTable> {
+    joinTableName: string;
+    mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<TColumn>;
+    };
+    constructor(joinTableName: string, mappedServiceToDb: {
+        [name in keyof ExtractModel<TTable>]: AbstractColumn<TColumn>;
+    });
+    columns: (fromColumn: AbstractColumn<TColumn, boolean, boolean>, toColumn: AbstractColumn<TColumn, boolean, boolean>) => Join<TTable>;
+}

package/builders/joinBuilders/joinWith.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const join_1 = require("./join");
+class JoinWith {
+    constructor(joinTableName, mappedServiceToDb) {
+        this.columns = (fromColumn, toColumn) => new join_1.default(this.joinTableName, fromColumn, toColumn, this.mappedServiceToDb);
+        this.joinTableName = joinTableName;
+        this.mappedServiceToDb = mappedServiceToDb;
+    }
+}
+exports.default = JoinWith;

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

@@ -0,0 +1,18 @@
+import { ExtractModel } from '../../../tables/inferTypes';
+export default class SelectResponseFourJoins<T1, T2, T3, T4, T5> {
+    _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>;
+    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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SelectResponseFourJoins {
+    constructor(t1, t2, t3, t4, t5) {
+        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]));
+            }
+            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;
+        this._t4 = t4;
+        this._t5 = t5;
+    }
+}
+exports.default = SelectResponseFourJoins;

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

@@ -0,0 +1,17 @@
+import { ExtractModel } from '../../../tables/inferTypes';
+export default class SelectResponseThreeJoins<T1, T2, T3, T4> {
+    private _t1;
+    private _t2;
+    private _t3;
+    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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SelectResponseThreeJoins {
+    constructor(t1, t2, t3, t4) {
+        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]));
+            }
+            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;
+        this._t4 = t4;
+    }
+}
+exports.default = SelectResponseThreeJoins;

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

@@ -0,0 +1,16 @@
+import { ExtractModel } from '../../../tables/inferTypes';
+export default class SelectResponseTwoJoins<T1, T2, T3> {
+    private _t1;
+    private _t2;
+    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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SelectResponseTwoJoins {
+    constructor(t1, t2, t3) {
+        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]));
+            }
+            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;
+    }
+}
+exports.default = SelectResponseTwoJoins;

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

@@ -0,0 +1,15 @@
+import { ExtractModel } from '../../../tables/inferTypes';
+export default class SelectResponseJoin<TTable1, TTable2> {
+    private _t1;
+    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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SelectResponseJoin {
+    constructor(t1, t2) {
+        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]));
+            }
+            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;
+    }
+}
+exports.default = SelectResponseJoin;

package/builders/joinBuilders/static.d.ts

@@ -0,0 +1,5 @@
+import ColumnType from '../../columns/types/columnType';
+import AbstractTable from '../../tables/abstractTable';
+import JoinWith from './joinWith';
+declare const to: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => JoinWith<ColumnType<{}>, TTable>;
+export default to;

package/builders/joinBuilders/static.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const joinWith_1 = require("./joinWith");
+const to = (table) => new joinWith_1.default(table.tableName(), table.mapServiceToDb());
+// eslint-disable-next-line import/prefer-default-export
+exports.default = to;

package/builders/lowLvlBuilders/alter.js

@@ -0,0 +1 @@
+"use strict";

package/builders/lowLvlBuilders/create.d.ts

@@ -0,0 +1,12 @@
+import AbstractTable from '../../tables/abstractTable';
+export default class Create<TTable extends AbstractTable<TTable>> {
+    private tableBuilder;
+    private enumBuilder;
+    private columnsBuilder;
+    private primaryKey;
+    private uniqueKey;
+    private tableClass;
+    private constructor();
+    static table: <StaticTTable extends AbstractTable<StaticTTable>>(tableClass: AbstractTable<StaticTTable>) => Create<StaticTTable>;
+    build: () => string;
+}

package/builders/lowLvlBuilders/create.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const column_1 = require("../../columns/column");
+const pgEnum_1 = require("../../columns/types/pgEnum");
+const ecranate_1 = require("../../utils/ecranate");
+class Create {
+    constructor(tableClass) {
+        this.tableBuilder = [];
+        this.enumBuilder = [];
+        this.columnsBuilder = [];
+        this.primaryKey = [];
+        this.uniqueKey = [];
+        this.build = () => {
+            this.tableBuilder.push('CREATE TABLE IF NOT EXISTS ');
+            this.tableBuilder.push(this.tableClass.tableName());
+            this.tableBuilder.push(' (');
+            const tableValues = Object.values(this.tableClass);
+            const columns = tableValues.filter((value) => value instanceof column_1.Column);
+            for (let i = 0; i < columns.length; i += 1) {
+                const column = columns[i];
+                if (column instanceof column_1.Column) {
+                    const columnType = column.getColumnType();
+                    if (columnType instanceof pgEnum_1.default) {
+                        // eslint-disable-next-line new-cap
+                        const enumValues = Object.values(columnType.codeType);
+                        let resValue = '';
+                        for (let j = 0; j < enumValues.length; j += 1) {
+                            resValue += `'${enumValues[j]}'`;
+                            if (j !== enumValues.length - 1) {
+                                resValue += ',';
+                            }
+                        }
+                        this.enumBuilder.push(`DO $$ BEGIN
+          CREATE TYPE ${columnType.dbName} AS ENUM (${resValue});
+      EXCEPTION
+          WHEN duplicate_object THEN null;
+      END $$;`);
+                    }
+                    this.columnsBuilder.push(ecranate_1.ecranate(column.getColumnName()));
+                    this.columnsBuilder.push(' ');
+                    this.columnsBuilder.push(column.isAutoIncrement() ? 'SERIAL' : column.getColumnType().getDbName());
+                    this.columnsBuilder.push(' ');
+                    this.columnsBuilder.push(column.getDefaultValue() != null ? `DEFAULT ${column.getColumnType().insertStrategy(column.getDefaultValue())}` : '');
+                    this.columnsBuilder.push(column.isNullableFlag ? '' : ' NOT NULL');
+                    const referenced = column.getReferenced();
+                    this.columnsBuilder.push(referenced != null ? ` REFERENCES ${referenced.getParentName()} (${referenced.getColumnName()})` : '');
+                    if (i !== columns.length - 1) {
+                        this.columnsBuilder.push(',');
+                    }
+                }
+            }
+            const primaryKeys = [];
+            const uniqueKeys = [];
+            Object.values(this.tableClass).forEach((field) => {
+                if (field instanceof column_1.Column) {
+                    if (field.primaryKeyName) {
+                        primaryKeys.push(field);
+                    }
+                    if (field.uniqueKeyName) {
+                        uniqueKeys.push(field);
+                    }
+                }
+            });
+            if (primaryKeys.length !== 0) {
+                this.primaryKey.push(',');
+                this.primaryKey.push(`\nCONSTRAINT ${this.tableClass.tableName()}_${primaryKeys[0].getColumnName()}`);
+                this.primaryKey.push(' PRIMARY KEY(');
+                for (let i = 0; i < primaryKeys.length; i += 1) {
+                    const column = primaryKeys[i];
+                    this.primaryKey.push(column.getColumnName());
+                    if (i !== primaryKeys.length - 1) {
+                        this.primaryKey.push(',');
+                    }
+                }
+                this.primaryKey.push(')');
+            }
+            if (uniqueKeys.length !== 0) {
+                const columnName = uniqueKeys[0].getColumnName();
+                this.uniqueKey.push(',');
+                this.uniqueKey.push(`\nCONSTRAINT ${this.tableClass.tableName()}_${columnName}`);
+                this.uniqueKey.push(' UNIQUE(');
+                for (let i = 0; i < uniqueKeys.length; i += 1) {
+                    const column = uniqueKeys[i];
+                    this.uniqueKey.push(column.getColumnName());
+                    if (i !== uniqueKeys.length - 1) {
+                        this.uniqueKey.push(',');
+                    }
+                }
+                this.uniqueKey.push(')');
+            }
+            return `${this.enumBuilder.join('')} ${this.tableBuilder.join('') + this.columnsBuilder.join('') + this.primaryKey.join('') + this.uniqueKey.join('')});`;
+        };
+        this.tableClass = tableClass;
+    }
+}
+exports.default = Create;
+Create.table = (tableClass) => new Create(tableClass);

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

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