drizzle-orm 0.9.18 → 0.10.2

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

@@ -4,31 +4,48 @@ import ColumnType from '../../../columns/types/columnType';
 import DB from '../../../db/db';
 import { ISession } from '../../../db/session';
 import AbstractTable from '../../../tables/abstractTable';
+import { CheckThreeTypes, PartialFor } 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, SelectResponseTwoJoins<TTable, TTable1, TTable2>> {
+export default class SelectTRBWithTwoJoins<TTable extends AbstractTable<TTable>, TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>, TPartial extends PartialFor<TTable> = {}, TPartial1 extends PartialFor<TTable1> = {}, TPartial2 extends PartialFor<TTable2> = {}> extends AbstractJoined<TTable, SelectResponseTwoJoins<TTable, TTable1, TTable2, TPartial, TPartial1, TPartial2>, TPartial> {
     private _join1;
     private _join2;
+    private _joinedPartial?;
+    private _joinedPartial1?;
     constructor(table: TTable, session: ISession, 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: {
+    }, orderBy?: AbstractColumn<ColumnType, boolean, boolean>, order?: Order, distinct?: AbstractColumn<ColumnType, boolean, boolean>, tablePartial?: TPartial, joinedPartial?: TPartial1, joinedPartial1?: TPartial2);
+    innerJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, 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: {
+    }, from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial>;
+    leftJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, 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: {
+    }, from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial>;
+    rightJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, 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: {
+    }, from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial>;
+    fullJoin<InputTable extends AbstractTable<InputTable>, TColumn extends ColumnType, IToTable extends AbstractTable<IToTable>, IToPartial extends PartialFor<IToTable> = {}>(fromTable: {
+        new (db: DB): InputTable;
+    }, 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>[];
+    }, from: (table: CheckThreeTypes<InputTable, TTable, TTable1, TTable2>) => AbstractColumn<TColumn, boolean, boolean, CheckThreeTypes<InputTable, TTable, TTable1, TTable2>>, to: (table: IToTable) => AbstractColumn<TColumn, boolean, boolean, IToTable>, partial?: IToPartial): SelectTRBWithThreeJoins<TTable, TTable1, TTable2, IToTable, TPartial, TPartial1, TPartial2, IToPartial>;
+    protected mapResponse(result: QueryResult<any>): SelectResponseTwoJoins<TTable, TTable1, TTable2, TPartial, TPartial1, TPartial2>;
+    protected joins(): Array<{
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        };
+        id?: number;
+    }>;
 }

package/builders/joinBuilders/builders/selectWithTwoJoins.js

@@ -1,59 +1,65 @@
 "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);
+    constructor(table, session, filter, join1, join2, props, orderBy, order, distinct, tablePartial, joinedPartial, joinedPartial1) {
+        super(table, filter, session, props, orderBy, order, distinct, tablePartial);
         this._join1 = join1;
         this._join2 = join2;
+        this._joinedPartial = joinedPartial;
+        this._joinedPartial1 = joinedPartial1;
     }
-    innerJoin(table, from, to) {
+    innerJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         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);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
     }
-    leftJoin(table, from, to) {
+    leftJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         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);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
     }
-    rightJoin(table, from, to) {
+    rightJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         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);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
     }
-    fullJoin(table, from, to) {
+    fullJoin(fromTable, table, from, to, partial) {
         const toTable = this._table.db.create(table);
-        const fromColumn = from(this._table);
+        const tableFrom = this._table.db.create(fromTable);
+        const fromColumn = from(tableFrom);
         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);
+        return new selectWithThreeJoins_1.default(this._table, this._session, this._filter, this._join1, this._join2, join, this._props, this._orderBy, this._order, this._distinct, this._partial, this._joinedPartial, this._joinedPartial1, partial);
     }
     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);
+        const response = this.fullOrPartial(this._table.mapServiceToDb(), result, this._partial);
+        const objects = this.fullOrPartial(parent, result, this._joinedPartial, 1);
+        const objectsTwo = this.fullOrPartial(parentTwo, result, this._joinedPartial1, 2);
         return new selectResponseTwoJoins_1.default(response, objects, objectsTwo);
     }
     joins() {
-        return [this._join1, this._join2];
+        return [{ join: this._join1, partial: this._joinedPartial, id: 1 },
+            { join: this._join2, partial: this._joinedPartial1, id: 2 }];
     }
 }
 exports.default = SelectTRBWithTwoJoins;

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

@@ -1,17 +1,18 @@
-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;
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+export default class SelectResponseFiveJoins<T1 extends AbstractTable<T1>, T2 extends AbstractTable<T2>, T3 extends AbstractTable<T3>, T4 extends AbstractTable<T4>, T5 extends AbstractTable<T5>, T6 extends AbstractTable<T6>, TPartial1 extends PartialFor<T1>, TPartial2 extends PartialFor<T2>, TPartial3 extends PartialFor<T3>, TPartial4 extends PartialFor<T4>, TPartial5 extends PartialFor<T5>, TPartial6 extends PartialFor<T6>> {
+    _t1: Array<FullOrPartial<T1, TPartial1>>;
+    _t2: Array<FullOrPartial<T2, TPartial2>>;
+    _t3: Array<FullOrPartial<T3, TPartial3>>;
+    _t4: Array<FullOrPartial<T4, TPartial4>>;
+    _t5: Array<FullOrPartial<T5, TPartial5>>;
+    _t6: Array<FullOrPartial<T6, TPartial6>>;
+    constructor(t1: Array<FullOrPartial<T1, TPartial1>>, t2: Array<FullOrPartial<T2, TPartial2>>, t3: Array<FullOrPartial<T3, TPartial3>>, t4: Array<FullOrPartial<T4, TPartial4>>, t5: Array<FullOrPartial<T5, TPartial5>>, t6: Array<FullOrPartial<T6, TPartial6>>);
+    map: <M>(imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>, t6: FullOrPartial<T6, TPartial6>) => M) => M[];
+    foreach: (imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>, t6: FullOrPartial<T6, TPartial6>) => 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: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>, t6: FullOrPartial<T6, TPartial6>) => TOne;
+        many: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>, t6: FullOrPartial<T6, TPartial6>) => TMany;
     }) => {
         one: TOne;
         many: TMany[];

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

@@ -1,16 +1,17 @@
-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;
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+export default class SelectResponseFourJoins<T1 extends AbstractTable<T1>, T2 extends AbstractTable<T2>, T3 extends AbstractTable<T3>, T4 extends AbstractTable<T4>, T5 extends AbstractTable<T5>, TPartial1 extends PartialFor<T1>, TPartial2 extends PartialFor<T2>, TPartial3 extends PartialFor<T3>, TPartial4 extends PartialFor<T4>, TPartial5 extends PartialFor<T5>> {
+    _t1: Array<FullOrPartial<T1, TPartial1>>;
+    _t2: Array<FullOrPartial<T2, TPartial2>>;
+    _t3: Array<FullOrPartial<T3, TPartial3>>;
+    _t4: Array<FullOrPartial<T4, TPartial4>>;
+    _t5: Array<FullOrPartial<T5, TPartial5>>;
+    constructor(t1: Array<FullOrPartial<T1, TPartial1>>, t2: Array<FullOrPartial<T2, TPartial2>>, t3: Array<FullOrPartial<T3, TPartial3>>, t4: Array<FullOrPartial<T4, TPartial4>>, t5: Array<FullOrPartial<T5, TPartial5>>);
+    map: <M>(imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>) => M) => M[];
+    foreach: (imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>) => 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: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>) => TOne;
+        many: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>, t5: FullOrPartial<T5, TPartial5>) => TMany;
     }) => {
         one: TOne;
         many: TMany[];

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

@@ -1,15 +1,16 @@
-import { ExtractModel } from '../../../tables/inferTypes';
-export default class SelectResponseThreeJoins<T1, T2, T3, T4> {
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+export default class SelectResponseThreeJoins<T1 extends AbstractTable<T1>, T2 extends AbstractTable<T2>, T3 extends AbstractTable<T3>, T4 extends AbstractTable<T4>, TPartial1 extends PartialFor<T1>, TPartial2 extends PartialFor<T2>, TPartial3 extends PartialFor<T3>, TPartial4 extends PartialFor<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;
+    constructor(t1: Array<FullOrPartial<T1, TPartial1>>, t2: Array<FullOrPartial<T2, TPartial2>>, t3: Array<FullOrPartial<T3, TPartial3>>, t4: Array<FullOrPartial<T4, TPartial4>>);
+    map: <M>(imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>) => M) => M[];
+    foreach: (imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>) => 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: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>) => TOne;
+        many: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>, t4: FullOrPartial<T4, TPartial4>) => TMany;
     }) => {
         one: TOne;
         many: TMany[];

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

@@ -1,14 +1,15 @@
-import { ExtractModel } from '../../../tables/inferTypes';
-export default class SelectResponseTwoJoins<T1, T2, T3> {
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+export default class SelectResponseTwoJoins<T1 extends AbstractTable<T1>, T2 extends AbstractTable<T2>, T3 extends AbstractTable<T3>, TPartial1 extends PartialFor<T1>, TPartial2 extends PartialFor<T2>, TPartial3 extends PartialFor<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;
+    constructor(t1: Array<FullOrPartial<T1, TPartial1>>, t2: Array<FullOrPartial<T2, TPartial2>>, t3: Array<FullOrPartial<T3, TPartial3>>);
+    map: <M>(imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>) => M) => M[];
+    foreach: (imac: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>) => 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: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>) => TOne;
+        many: (t1: FullOrPartial<T1, TPartial1>, t2: FullOrPartial<T2, TPartial2>, t3: FullOrPartial<T3, TPartial3>) => TMany;
     }) => {
         one: TOne;
         many: TMany[];

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

@@ -1,13 +1,14 @@
-import { ExtractModel } from '../../../tables/inferTypes';
-export default class SelectResponseJoin<TTable1, TTable2> {
+import AbstractTable from '../../../tables/abstractTable';
+import { FullOrPartial, PartialFor } from '../../../tables/inferTypes';
+export default class SelectResponseJoin<TTable1 extends AbstractTable<TTable1>, TTable2 extends AbstractTable<TTable2>, TPartial1 extends PartialFor<TTable1>, TPartial2 extends PartialFor<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;
+    constructor(t1: Array<FullOrPartial<TTable1, TPartial1>>, t2: Array<FullOrPartial<TTable2, TPartial2>>);
+    map: <M>(imac: (t1: FullOrPartial<TTable1, TPartial1>, t2: FullOrPartial<TTable2, TPartial2>) => M) => M[];
+    foreach: (imac: (t1: FullOrPartial<TTable1, TPartial1>, t2: FullOrPartial<TTable2, TPartial2>) => 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: (t1: FullOrPartial<TTable1, TPartial1>, t2: FullOrPartial<TTable2, TPartial2>) => TOne;
+        many: (t1: FullOrPartial<TTable1, TPartial1>, t2: FullOrPartial<TTable2, TPartial2>) => TMany;
     }) => {
         one: TOne;
         many: TMany[];

package/builders/lowLvlBuilders/selects/select.d.ts

@@ -1,5 +1,9 @@
+import { AbstractColumn } from '../../../columns/column';
+import ColumnType from '../../../columns/types/columnType';
 import { AbstractTable } from '../../../tables';
 import SelectFrom from './selectFrom';
 export default class Select {
-    static from: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => SelectFrom;
+    static from: <TTable extends AbstractTable<TTable>, TType extends ColumnType<any>, TColumn extends AbstractColumn<TType, boolean, boolean, TTable>, T extends {
+        [name: string]: TColumn;
+    } = {}>(table: AbstractTable<TTable>, partial?: T | undefined) => SelectFrom;
 }

package/builders/lowLvlBuilders/selects/select.js

@@ -5,8 +5,9 @@ const selectFrom_1 = require("./selectFrom");
 class Select {
 }
 exports.default = Select;
-Select.from = (table) => {
-    const aggregator = new selectAggregator_1.default(table);
+// eslint-disable-next-line max-len
+Select.from = (table, partial) => {
+    const aggregator = new selectAggregator_1.default(table, partial);
     aggregator.appendFrom(table.tableName());
     return new selectFrom_1.default(aggregator);
 };

package/builders/lowLvlBuilders/selects/selectFrom.d.ts

@@ -9,11 +9,17 @@ import WhereSelect from './whereSelect';
 export default class SelectFrom {
     private _aggregator;
     constructor(aggregator: SelectAggregator);
-    joined: (joins: Array<Join<any> | undefined>) => SelectJoined;
+    joined: (joins: {
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        } | undefined;
+        id?: number | undefined;
+    }[]) => SelectJoined;
     limit: (limit?: number | undefined) => SelectFrom;
     offset: (offset?: number | undefined) => SelectFrom;
-    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined, order?: Order | undefined) => SelectFrom;
-    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined) => SelectFrom;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectFrom;
+    distinct: (column?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined) => SelectFrom;
     filteredBy: (filters: Expr) => WhereSelect;
     build: () => string;
 }

package/builders/lowLvlBuilders/selects/selectJoined.d.ts

@@ -8,10 +8,16 @@ import WhereSelect from './whereSelect';
 export default class SelectJoined {
     private _aggregator;
     constructor(aggregator: SelectAggregator);
-    apply: (joins: Array<Join<any> | undefined>) => SelectJoined;
+    apply: (joins: {
+        join: Join<any>;
+        partial?: {
+            [name: string]: AbstractColumn<ColumnType<any>, boolean, boolean, any>;
+        } | undefined;
+        id?: number | undefined;
+    }[]) => SelectJoined;
     limit: (limit?: number | undefined) => SelectJoined;
     offset: (offset?: number | undefined) => SelectJoined;
-    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined, order?: Order | undefined) => SelectJoined;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => SelectJoined;
     filteredBy: (filters: Expr) => WhereSelect;
     build: () => string;
 }

package/builders/lowLvlBuilders/selects/whereSelect.d.ts

@@ -8,7 +8,7 @@ export default class WhereSelect {
     constructor(aggregator: SelectAggregator);
     limit: (limit?: number | undefined) => WhereSelect;
     offset: (offset?: number | undefined) => WhereSelect;
-    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined, order?: Order | undefined) => WhereSelect;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean, any> | undefined, order?: Order | undefined) => WhereSelect;
     apply: (filters: Expr) => WhereSelect;
     build: () => string;
 }

package/builders/requestBuilders/updates/static.d.ts

@@ -2,6 +2,6 @@ import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import { ExtractCodeType } from '../../../tables/inferTypes';
 import { UpdateCustomExpr, UpdateExpr } from './updates';
-export declare const set: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(column: T, value: ExtractCodeType<T>) => UpdateExpr;
-export declare const incrementBy: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(value: number) => UpdateCustomExpr<T>;
+export declare const set: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(column: T, value: ExtractCodeType<T>) => UpdateExpr;
+export declare const incrementBy: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(value: number) => UpdateCustomExpr<T>;
 export declare const combine: (updates: Array<UpdateExpr>) => UpdateExpr;

package/builders/requestBuilders/where/const.js

@@ -6,6 +6,9 @@ class Const extends where_1.default {
     constructor(value) {
         super();
         this.toQuery = () => {
+            if (this.value instanceof Date) {
+                return `'${this.value.toISOString()}'`;
+            }
             if (ecranate_1.shouldEcranate(this.value)) {
                 return `'${this.value.toString()}'`;
             }

package/builders/requestBuilders/where/constArray.js

@@ -9,6 +9,9 @@ class ConstArray extends where_1.default {
             const finalArray = [];
             for (let i = 0; i < this.values.length; i += 1) {
                 const value = this.values[i];
+                if (value instanceof Date) {
+                    return `'${value.toISOString()}'`;
+                }
                 if (ecranate_1.shouldEcranate(value)) {
                     finalArray.push(`'${value.toString()}'`);
                 }

package/builders/requestBuilders/where/static.d.ts

@@ -2,15 +2,15 @@ import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import { ExtractCodeType } from '../../../tables/inferTypes';
 import Expr from './where';
-export declare const eq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const eq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;
 export declare const raw: (customQuery: string) => Expr;
 export declare const and: (expressions: Expr[]) => Expr;
 export declare const or: (expressions: Expr[]) => Expr;
-export declare const like: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
-export declare const inArray: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>[]) => Expr;
-export declare const greater: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
-export declare const less: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
-export declare const greaterEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
-export declare const lessEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
-export declare const isNull: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T) => Expr;
-export declare const notEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const like: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const inArray: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>[]) => Expr;
+export declare const greater: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const less: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const greaterEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const lessEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;
+export declare const isNull: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T) => Expr;
+export declare const notEq: <T extends AbstractColumn<ColumnType<any>, boolean, boolean, any>>(left: T, value: ExtractCodeType<T>) => Expr;

package/columns/column.d.ts

@@ -8,19 +8,19 @@ export declare enum Defaults {
 }
 declare type PgTimes = PgTimestamptz | PgTime | PgTimestamp;
 export declare type ExtractColumnType<T extends ColumnType> = T extends ColumnType<infer TCodeType> ? T extends PgTimes ? TCodeType | Defaults : TCodeType : never;
-export declare abstract class AbstractColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false> {
+export declare abstract class AbstractColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false, TParent extends AbstractTable<any> = any> {
     isNullableFlag: boolean;
     primaryKeyName?: string;
     uniqueKeyName?: string;
     protected onDelete?: string;
     protected onUpdate?: string;
-    protected parent: AbstractTable<any>;
+    protected parent: TParent;
     protected parentTableName: string;
     protected columnType: T;
     protected columnName: string;
     protected defaultParam: any;
-    protected referenced: AbstractColumn<T, boolean, boolean>;
-    constructor(parent: AbstractTable<any>, columnName: string, columnType: T);
+    protected referenced: AbstractColumn<T, boolean, boolean, TParent>;
+    constructor(parent: TParent, columnName: string, columnType: T);
     getOnDelete: () => string | undefined;
     getOnUpdate: () => string | undefined;
     getAlias: () => string;
@@ -28,35 +28,39 @@ export declare abstract class AbstractColumn<T extends ColumnType, TNullable ext
     getParentName: () => string;
     abstract foreignKey<ITable extends AbstractTable<ITable>>(table: {
         new (db: DB): ITable;
-    }, callback: (table: ITable) => AbstractColumn<T, boolean, boolean>, onConstraint: {
+    }, callback: (table: ITable) => AbstractColumn<T, boolean, boolean, TParent>, onConstraint: {
         onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
         onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
     }): AbstractColumn<T, TNullable, TAutoIncrement>;
     defaultValue: (value: ExtractColumnType<T>) => this;
-    abstract primaryKey(): AbstractColumn<T, boolean, boolean>;
+    abstract primaryKey(): AbstractColumn<T, boolean, boolean, TParent>;
     unique: () => this;
-    abstract notNull(): AbstractColumn<T, boolean, boolean>;
+    abstract notNull(): AbstractColumn<T, boolean, boolean, TParent>;
     getColumnName: () => string;
-    getReferenced: () => AbstractColumn<T, boolean, boolean>;
+    getReferenced: () => AbstractColumn<T, boolean, boolean, TParent>;
     getColumnType: () => T;
     getDefaultValue: () => any;
 }
-export declare class Column<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false> extends AbstractColumn<T, TNullable, TAutoIncrement> {
-    constructor(parent: AbstractTable<any>, columnName: string, columnType: T);
-    notNull(): Column<T, TAutoIncrement extends true ? true : TNullable extends true ? false : true, TAutoIncrement>;
-    primaryKey(): Column<T, TAutoIncrement extends true ? true : false, TAutoIncrement>;
-    foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => Column<T, boolean, boolean>, onConstraint?: {
+export declare class Column<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false, TParent extends AbstractTable<any> = any> extends AbstractColumn<T, TNullable, TAutoIncrement, TParent> {
+    constructor(parent: TParent, columnName: string, columnType: T);
+    notNull(): Column<T, TAutoIncrement extends true ? true : TNullable extends true ? false : true, TAutoIncrement, TParent>;
+    primaryKey(): Column<T, TAutoIncrement extends true ? true : false, TAutoIncrement, TParent>;
+    foreignKey(table: new (db: DB) => TParent, callback: (table: this) => Column<T, boolean, boolean, TParent>, onConstraint?: {
         onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
         onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
-    }): Column<T, TNullable, TAutoIncrement>;
+    }): Column<T, TNullable, TAutoIncrement, TParent>;
+    foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => Column<T, boolean, boolean, ITable>, onConstraint?: {
+        onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+        onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
+    }): Column<T, TNullable, TAutoIncrement, TParent>;
 }
-export declare class IndexedColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false> extends AbstractColumn<T, TNullable, TAutoIncrement> {
-    constructor(parent: AbstractTable<any>, columnName: string, columnType: T, nullable: TNullable);
-    notNull(): IndexedColumn<T, TAutoIncrement extends true ? true : TNullable extends true ? false : true, TAutoIncrement>;
-    primaryKey(): IndexedColumn<T, TAutoIncrement extends true ? true : false, TAutoIncrement>;
-    foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => IndexedColumn<T, boolean, boolean>, onConstraint?: {
+export declare class IndexedColumn<T extends ColumnType, TNullable extends boolean = true, TAutoIncrement extends boolean = false, TParent extends AbstractTable<any> = any> extends AbstractColumn<T, TNullable, TAutoIncrement, TParent> {
+    constructor(parent: TParent, columnName: string, columnType: T, nullable: TNullable);
+    notNull(): IndexedColumn<T, TAutoIncrement extends true ? true : TNullable extends true ? false : true, TAutoIncrement, TParent>;
+    primaryKey(): IndexedColumn<T, TAutoIncrement extends true ? true : false, TAutoIncrement, TParent>;
+    foreignKey<ITable extends AbstractTable<ITable>>(table: new (db: DB) => ITable, callback: (table: ITable) => IndexedColumn<T, boolean, boolean, TParent>, onConstraint?: {
         onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
         onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'SET DEFAULT';
-    }): IndexedColumn<T, TNullable, TAutoIncrement>;
+    }): IndexedColumn<T, TNullable, TAutoIncrement, TParent>;
 }
 export {};

package/columns/column.js

@@ -48,7 +48,14 @@ class Column extends AbstractColumn {
         return this;
     }
     foreignKey(table, callback, onConstraint) {
-        const tableInstance = this.getParent().db.create(table);
+        let tableInstance;
+        // eslint-disable-next-line new-cap
+        if (typeof this !== typeof this.getParent()) {
+            tableInstance = this.getParent().db.create(table);
+        }
+        else {
+            tableInstance = this;
+        }
         this.referenced = callback(tableInstance);
         this.onDelete = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onDelete) ? `ON DELETE ${onConstraint.onDelete}` : undefined;
         this.onUpdate = (onConstraint === null || onConstraint === void 0 ? void 0 : onConstraint.onUpdate) ? `ON UPDATE ${onConstraint.onUpdate}` : undefined;

package/docs/cases/simple_delete.js

@@ -22,7 +22,7 @@ const usersTable_1 = require("../tables/usersTable");
             .all();
         const deletedUserGroup = await userGroupsTable.delete()
             .where(builders_1.eq(userGroupsTable.id, 3))
-            .first();
+            .findOne();
     }
     catch (e) {
         console.log(e);

package/docs/cases/simple_insert.js

@@ -1,19 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/no-unused-vars */
-const __1 = require("../..");
+const create_1 = require("../../builders/lowLvlBuilders/create");
+const dbConnector_1 = require("../../db/dbConnector");
+const consoleLogger_1 = require("../../logger/consoleLogger");
 const citiesTable_1 = require("../tables/citiesTable");
 const userGroupsTable_1 = require("../tables/userGroupsTable");
 const usersTable_1 = require("../tables/usersTable");
 (async () => {
     try {
-        const db = await new __1.DbConnector()
+        const db = await new dbConnector_1.default()
             .connectionString('postgresql://postgres@127.0.0.1/drizzle-docs')
             .connect();
         const usersTable = new usersTable_1.default(db);
         const citiesTable = new citiesTable_1.default(db);
         const userGroupsTable = new userGroupsTable_1.default(db);
-        await db.session().execute(__1.Create.table(usersTable).build());
+        await db.session().execute(create_1.default.table(usersTable).build());
+        await db.session().execute(create_1.default.table(citiesTable).build());
+        await db.session().execute(create_1.default.table(userGroupsTable).build());
+        db.useLogger(new consoleLogger_1.default());
         await usersTable.insert({
             decimalField: 12.4,
             createdAt: new Date(),
@@ -24,7 +29,7 @@ const usersTable_1 = require("../tables/usersTable");
         }).all();
         const insertedUserGroup = await userGroupsTable.insert({
             name: 'firstGroup',
-        }).first();
+        }).findOne();
         const manyInsertedCities = await citiesTable.insertMany([{
                 foundationDate: new Date(),
                 location: 'USA',