drizzle-orm 0.9.1 → 0.9.2

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

@@ -1,12 +1,10 @@
-import { Column } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
 import InsertAggregator from '../../aggregators/insertAggregator';
 import ValuesInsert from './valuesInsert';
 export default class InsertInto {
     private _aggregator;
     constructor(aggregator: InsertAggregator);
-    values: <T>(values: {
+    values: (values: {
         [name: string]: any;
-    }[], columns: { [name in keyof T]: Column<ColumnType<{}>, true, false>; }) => ValuesInsert;
+    }[]) => ValuesInsert;
     build: () => string;
 }

package/builders/lowLvlBuilders/inserts/insertInto.js

@@ -4,7 +4,8 @@ const valuesInsert_1 = require("./valuesInsert");
 class InsertInto {
     constructor(aggregator) {
         // @TODO refactor!!
-        this.values = (values, columns) => new valuesInsert_1.default(this._aggregator).apply(values, columns);
+        this.values = (values) => new valuesInsert_1.default(this._aggregator)
+            .apply(values);
         this.build = () => this._aggregator.buildQuery();
         this._aggregator = aggregator;
     }

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

@@ -1,15 +1,13 @@
-import { Column } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
-import { ExtractModel, Indexing } from '../../../tables/inferTypes';
+import { Indexing } from '../../../tables/inferTypes';
 import InsertAggregator from '../../aggregators/insertAggregator';
 import UpdateExpr from '../../requestBuilders/updates/updates';
 import OnConflictInsert from './onConflictInsert';
 export default class ValuesInsert {
     private _aggregator;
     constructor(aggregator: InsertAggregator);
-    apply: <T>(values: {
+    apply: (values: {
         [name: string]: any;
-    }[], columns: { [name in keyof ExtractModel<T>]: Column<ColumnType<{}>, true, false>; }) => ValuesInsert;
+    }[]) => ValuesInsert;
     onConflict: (updates: UpdateExpr, column: Indexing) => OnConflictInsert;
     build: () => string;
 }

package/builders/lowLvlBuilders/inserts/valuesInsert.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const onConflictInsert_1 = require("./onConflictInsert");
 class ValuesInsert {
     constructor(aggregator) {
-        this.apply = (values, columns) => {
-            this._aggregator.appendColumns(values);
-            this._aggregator.appendValues(columns, values);
+        this.apply = (values) => {
+            this._aggregator.appendColumns();
+            this._aggregator.appendValues(values);
             return this;
         };
         this.onConflict = (updates, column) => new onConflictInsert_1.default(this._aggregator).apply(updates, column);

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

@@ -1,6 +1,5 @@
-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: (tableName: string, columns: AbstractColumn<ColumnType>[]) => SelectFrom;
+    static from: <TTable extends AbstractTable<TTable>>(table: AbstractTable<TTable>) => SelectFrom;
 }

package/builders/lowLvlBuilders/selects/select.js

@@ -5,8 +5,8 @@ const selectFrom_1 = require("./selectFrom");
 class Select {
 }
 exports.default = Select;
-Select.from = (tableName, columns) => {
-    const aggregator = new selectAggregator_1.default(tableName);
-    aggregator.appendFrom(tableName).appendFields(columns);
+Select.from = (table) => {
+    const aggregator = new selectAggregator_1.default(table);
+    aggregator.appendFrom(table.tableName());
     return new selectFrom_1.default(aggregator);
 };

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

@@ -9,10 +9,11 @@ import WhereSelect from './whereSelect';
 export default class SelectFrom {
     private _aggregator;
     constructor(aggregator: SelectAggregator);
-    joined: (joins: Array<Join<any>>) => SelectJoined;
-    limit: (limit: number) => SelectFrom;
-    offset: (offset: number) => SelectFrom;
-    orderBy: (orderBy: AbstractColumn<ColumnType, boolean, boolean>, order: Order) => SelectFrom;
+    joined: (joins: Array<Join<any> | 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;
     filteredBy: (filters: Expr) => WhereSelect;
     build: () => string;
 }

package/builders/lowLvlBuilders/selects/selectFrom.js

@@ -17,6 +17,12 @@ class SelectFrom {
             this._aggregator.orderBy(orderBy, order);
             return this;
         };
+        this.distinct = (column) => {
+            if (column) {
+                this._aggregator.distinct(column);
+            }
+            return this;
+        };
         this.filteredBy = (filters) => new whereSelect_1.default(this._aggregator).apply(filters);
         this.build = () => this._aggregator.buildQuery();
         this._aggregator = aggregator;

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

@@ -1,4 +1,4 @@
-import { Column } from '../../../columns';
+import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import SelectAggregator from '../../aggregators/selectAggregator';
 import Order from '../../highLvlBuilders/order';
@@ -8,10 +8,10 @@ import WhereSelect from './whereSelect';
 export default class SelectJoined {
     private _aggregator;
     constructor(aggregator: SelectAggregator);
-    apply: (joins: Array<Join<{}>>) => SelectJoined;
-    limit: (limit: number) => SelectJoined;
-    offset: (offset: number) => SelectJoined;
-    orderBy: (orderBy: Column<ColumnType, boolean, boolean>, order: Order) => SelectJoined;
+    apply: (joins: Array<Join<any> | undefined>) => SelectJoined;
+    limit: (limit?: number | undefined) => SelectJoined;
+    offset: (offset?: number | undefined) => SelectJoined;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined, order?: Order | undefined) => SelectJoined;
     filteredBy: (filters: Expr) => WhereSelect;
     build: () => string;
 }

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

@@ -1,4 +1,4 @@
-import { Column } from '../../../columns';
+import { AbstractColumn } from '../../../columns/column';
 import ColumnType from '../../../columns/types/columnType';
 import SelectAggregator from '../../aggregators/selectAggregator';
 import Order from '../../highLvlBuilders/order';
@@ -6,9 +6,9 @@ import Expr from '../../requestBuilders/where/where';
 export default class WhereSelect {
     private _aggregator;
     constructor(aggregator: SelectAggregator);
-    limit: (limit: number) => WhereSelect;
-    offset: (offset: number) => WhereSelect;
-    orderBy: (orderBy: Column<ColumnType, boolean, boolean>, order: Order) => WhereSelect;
+    limit: (limit?: number | undefined) => WhereSelect;
+    offset: (offset?: number | undefined) => WhereSelect;
+    orderBy: (orderBy?: AbstractColumn<ColumnType<{}>, boolean, boolean> | undefined, order?: Order | undefined) => WhereSelect;
     apply: (filters: Expr) => WhereSelect;
     build: () => string;
 }

package/builders/lowLvlBuilders/updates/update.d.ts

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

package/builders/lowLvlBuilders/updates/update.js

@@ -5,8 +5,8 @@ const updateIn_1 = require("./updateIn");
 class Update {
 }
 exports.default = Update;
-Update.in = (tableName) => {
-    const aggregator = new updateAggregator_1.default(tableName);
-    aggregator.appendFrom(tableName);
+Update.in = (table) => {
+    const aggregator = new updateAggregator_1.default(table);
+    aggregator.appendFrom(table.tableName());
     return new updateIn_1.default(aggregator);
 };

package/builders/lowLvlBuilders/updates/updateIn.d.ts

@@ -1,12 +1,10 @@
-import { AbstractColumn } from '../../../columns/column';
-import ColumnType from '../../../columns/types/columnType';
 import UpdateAggregator from '../../aggregators/updateAggregator';
 import UpdateExpr from '../../requestBuilders/updates/updates';
 import WhereSet from './whereSet';
 export default class UpdateIn {
     private _aggregator;
     constructor(aggregator: UpdateAggregator);
-    columns: (columns: AbstractColumn<ColumnType>[]) => UpdateIn;
+    columns: () => UpdateIn;
     set: (updates: UpdateExpr) => WhereSet<unknown, unknown>;
     build: () => string;
 }

package/builders/lowLvlBuilders/updates/updateIn.js

@@ -3,10 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const whereSet_1 = require("./whereSet");
 class UpdateIn {
     constructor(aggregator) {
-        this.columns = (columns) => {
-            this._aggregator.appendFields(columns);
-            return new UpdateIn(this._aggregator);
-        };
+        this.columns = () => new UpdateIn(this._aggregator);
         this.set = (updates) => new whereSet_1.default(this._aggregator).apply(updates);
         this.build = () => this._aggregator.buildQuery();
         this._aggregator = aggregator;

package/builders/requestBuilders/where/const.js

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

package/builders/requestBuilders/where/constArray.js

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

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

@@ -0,0 +1,6 @@
+import Expr from './where';
+export default class IsNull extends Expr {
+    private left;
+    constructor(left: Expr);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/isNull.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class IsNull extends where_1.default {
+    constructor(left) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()} is null`;
+        this.left = left;
+    }
+}
+exports.default = IsNull;

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

@@ -0,0 +1,7 @@
+import Expr from './where';
+export default class NotEqWhere extends Expr {
+    private left;
+    private right;
+    constructor(left: Expr, right: Expr);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/notEqWhere.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class NotEqWhere extends where_1.default {
+    constructor(left, right) {
+        super();
+        this.toQuery = () => `${this.left.toQuery()}!=${this.right.toQuery()}`;
+        this.left = left;
+        this.right = right;
+    }
+}
+exports.default = NotEqWhere;

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

@@ -0,0 +1,6 @@
+import Expr from './where';
+export default class RawWhere extends Expr {
+    private custom;
+    constructor(custom: string);
+    toQuery: () => string;
+}

package/builders/requestBuilders/where/rawWhere.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const where_1 = require("./where");
+class RawWhere extends where_1.default {
+    constructor(custom) {
+        super();
+        this.custom = custom;
+        this.toQuery = () => this.custom;
+    }
+}
+exports.default = RawWhere;

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

@@ -3,6 +3,7 @@ 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 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;
@@ -11,3 +12,5 @@ export declare const greater: <T extends AbstractColumn<ColumnType<any>, boolean
 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;

package/builders/requestBuilders/where/static.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lessEq = exports.greaterEq = exports.less = exports.greater = exports.inArray = exports.like = exports.or = exports.and = exports.eq = void 0;
+exports.notEq = exports.isNull = exports.lessEq = exports.greaterEq = exports.less = exports.greater = exports.inArray = exports.like = exports.or = exports.and = exports.raw = exports.eq = void 0;
 const and_1 = require("./and");
 const const_1 = require("./const");
 const constArray_1 = require("./constArray");
@@ -8,14 +8,19 @@ const eqWhere_1 = require("./eqWhere");
 const greater_1 = require("./greater");
 const greaterEq_1 = require("./greaterEq");
 const in_1 = require("./in");
+const isNull_1 = require("./isNull");
 const less_1 = require("./less");
 const lessEq_1 = require("./lessEq");
 const like_1 = require("./like");
+const notEqWhere_1 = require("./notEqWhere");
 const or_1 = require("./or");
+const rawWhere_1 = require("./rawWhere");
 const var_1 = require("./var");
 // eslint-disable-next-line max-len
 const eq = (left, value) => new eqWhere_1.default(new var_1.default(left), new const_1.default(value));
 exports.eq = eq;
+const raw = (customQuery) => new rawWhere_1.default(customQuery);
+exports.raw = raw;
 const and = (expressions) => new and_1.default(expressions);
 exports.and = and;
 const or = (expressions) => new or_1.default(expressions);
@@ -32,3 +37,7 @@ const greaterEq = (left, value) => new greaterEq_1.default({ left: new var_1.def
 exports.greaterEq = greaterEq;
 const lessEq = (left, value) => new lessEq_1.default({ left: new var_1.default(left), right: new const_1.default(value) });
 exports.lessEq = lessEq;
+const isNull = (left) => new isNull_1.default(new var_1.default(left));
+exports.isNull = isNull;
+const notEq = (left, value) => new notEqWhere_1.default(new var_1.default(left), new const_1.default(value));
+exports.notEq = notEq;

package/builders/requestBuilders/where/var.js

@@ -5,7 +5,7 @@ const where_1 = require("./where");
 class Var extends where_1.default {
     constructor(column) {
         super();
-        this.toQuery = () => `${this.column.getParentName()}.${(0, ecranate_1.ecranate)(this.column.getColumnName())}`;
+        this.toQuery = () => `${this.column.getParentName()}.${ecranate_1.ecranate(this.column.getColumnName())}`;
         this.column = column;
     }
 }

package/db/session.js

@@ -6,10 +6,10 @@ class Session {
         this.pool = pool;
         this.execute = async (query) => {
             try {
-                return (0, baseError_1.right)(await this.pool.query(query));
+                return baseError_1.right(await this.pool.query(query));
             }
             catch (e) {
-                return (0, baseError_1.left)({
+                return baseError_1.left({
                     type: baseError_1.PgSessionError.PgQueryExecutionError,
                     reason: e,
                 });

package/docs/cases/simple_delete.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+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()
+            .connectionString('postgresql://postgres@127.0.0.1/drizzle')
+            .connect();
+        const usersTable = new usersTable_1.default(db);
+        const citiesTable = new citiesTable_1.default(db);
+        const userGroupsTable = new userGroupsTable_1.default(db);
+        await usersTable.delete()
+            .where(builders_1.eq(usersTable.id, 1))
+            .execute();
+        const deletedCities = await citiesTable.delete()
+            .where(builders_1.eq(citiesTable.id, 2))
+            .all();
+        const deletedUserGroup = await userGroupsTable.delete()
+            .where(builders_1.eq(userGroupsTable.id, 3))
+            .first();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/docs/cases/simple_insert.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+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()
+            .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 usersTable.insert({
+            decimalField: 12.4,
+            createdAt: new Date(),
+            role: 'guest',
+        }).execute();
+        const insertedCities = await citiesTable.insert({
+            foundationDate: new Date(),
+        }).all();
+        const insertedUserGroup = await userGroupsTable.insert({
+            name: 'firstGroup',
+        }).first();
+        const manyInsertedCities = await citiesTable.insertMany([{
+                foundationDate: new Date(),
+                location: 'USA',
+            }, {
+                foundationDate: new Date(),
+                location: 'USA',
+                userId: 2,
+            }]).all();
+        const conflictInsertedUsers = await usersTable.insertMany([{
+                decimalField: 12.4,
+                createdAt: new Date(),
+                role: 'guest',
+            }, {
+                decimalField: 32.4,
+                createdAt: new Date(),
+                role: 'admin',
+                phone: '+1808',
+            }])
+            .onConflict((table) => table.phoneIndex, { isArchived: true }).all();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/docs/cases/simple_join.d.ts

@@ -0,0 +1 @@
+export {};

package/docs/cases/simple_join.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+const citiesTable_1 = require("../tables/citiesTable");
+const userGroupsTable_1 = require("../tables/userGroupsTable");
+const usersTable_1 = require("../tables/usersTable");
+const usersToUserGroups_1 = require("../tables/usersToUserGroups");
+(async () => {
+    var _a, _b, _c, _d, _e, _f;
+    try {
+        const db = await new __1.DbConnector()
+            .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 usersToUserGroupsTable = new usersToUserGroups_1.default(db);
+        const userGroupsTable = new userGroupsTable_1.default(db);
+        await db.session().execute(__1.Create.table(usersTable).build());
+        await db.session().execute(__1.Create.table(citiesTable).build());
+        await db.session().execute(__1.Create.table(userGroupsTable).build());
+        await db.session().execute(__1.Create.table(usersToUserGroupsTable).build());
+        const userRes = await usersTable.insertMany([{
+                decimalField: 4.2,
+                createdAt: new Date(),
+                role: 'guest',
+            }, {
+                decimalField: 5.8,
+                createdAt: new Date(),
+                role: 'user',
+            }]).all();
+        const citiesRes = await citiesTable.insertMany([{
+                foundationDate: new Date(),
+                userId: (_a = userRes[0]) === null || _a === void 0 ? void 0 : _a.id,
+            }, {
+                foundationDate: new Date(),
+                userId: (_b = userRes[1]) === null || _b === void 0 ? void 0 : _b.id,
+            }]).all();
+        const userGroups = await userGroupsTable.insertMany([{
+                name: 'firstGroup',
+            }, {
+                name: 'secondGroup',
+            }]).all();
+        await usersToUserGroupsTable.insertMany([{
+                userId: (_c = userRes[0]) === null || _c === void 0 ? void 0 : _c.id,
+                groupId: (_d = userGroups[0]) === null || _d === void 0 ? void 0 : _d.id,
+            },
+            {
+                userId: (_e = userRes[1]) === null || _e === void 0 ? void 0 : _e.id,
+                groupId: (_f = userGroups[1]) === null || _f === void 0 ? void 0 : _f.id,
+            }]).execute();
+        // map case
+        const userWithCities = await citiesTable.select()
+            .where(builders_1.eq(citiesTable.id, 1))
+            .leftJoin(usersTable_1.default, (city) => city.userId, (users) => users.id)
+            .execute();
+        const citiesWithUserObject = userWithCities.map((city, user) => ({ ...city, user }));
+        // foreach case
+        // const userWithCities1 = await citiesTable.select()
+        //   .where(eq(citiesTable.id, 1))
+        //   .leftJoin(UsersTable,
+        //     (city) => city.userId,
+        //     (users) => users.id)
+        //   .execute();
+        // let user;
+        // const cities = [];
+        // userWithCities.foreach((dbCity, dbUser) => {
+        //   cities.push(dbCity);
+        //   user = dbUser;
+        // });
+        // group case
+        const usersWithUserGroups = await usersToUserGroupsTable.select()
+            .where(builders_1.eq(userGroupsTable.id, 1))
+            .leftJoin(usersTable_1.default, (userToGroup) => userToGroup.userId, (users) => users.id)
+            .leftJoin(userGroupsTable_1.default, (userToGroup) => userToGroup.groupId, (users) => users.id)
+            .execute();
+        const userGroupWithUsers = usersWithUserGroups.group({
+            one: (_, dbUser, dbUserGroup) => dbUser,
+            many: (_, dbUser, dbUserGroup) => dbUserGroup,
+        });
+        const userWithGroups = {
+            ...userGroupWithUsers.one,
+            groups: userGroupWithUsers.many,
+        };
+        // console.log('city', city!);
+        // console.log('cityUsers', cityUsers);
+        // console.log('cityWithUsers', forEachCities);
+        // console.log('cityWithUsers1', forEachUsers);
+        // how to handle many-to-many relations
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/docs/cases/simple_select.d.ts

@@ -0,0 +1 @@
+export {};

package/docs/cases/simple_select.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+const order_1 = require("../../builders/highLvlBuilders/order");
+const static_1 = require("../../builders/requestBuilders/where/static");
+const usersTable_1 = require("../tables/usersTable");
+(async () => {
+    try {
+        const db = await new __1.DbConnector()
+            .connectionString('postgresql://postgres@127.0.0.1/drizzle')
+            .connect();
+        const usersTable = new usersTable_1.default(db);
+        // select all
+        const allSelect = await usersTable.select().all();
+        // select first
+        const firstSelect = await usersTable.select().first();
+        // select using filters
+        const eqSelect = await usersTable.select().where(builders_1.eq(usersTable.phone, 'hello')).all();
+        const andSelect = await usersTable.select().where(builders_1.and([builders_1.eq(usersTable.phone, 'hello')])).all();
+        const orSelect = await usersTable.select().where(builders_1.or([builders_1.eq(usersTable.phone, 'hello')])).all();
+        // select using limit, offset
+        const limitOffsetSelect = await usersTable.select({ limit: 10, offset: 10 }).all();
+        const likeSelect = await usersTable.select().where(builders_1.like(usersTable.phone, 'hello')).all();
+        const inArraySelect = usersTable.select().where(static_1.inArray(usersTable.phone, ['hello'])).all();
+        const greaterSelect = usersTable.select().where(static_1.greater(usersTable.bigIntField, 3)).all();
+        const lessSelect = usersTable.select().where(static_1.less(usersTable.bigIntField, 3)).all();
+        const greaterEqSelect = usersTable.select().where(static_1.greaterEq(usersTable.bigIntField, 3)).all();
+        const lessEqSelect = usersTable.select().where(static_1.lessEq(usersTable.bigIntField, 3)).all();
+        const isNullSelect = usersTable.select().where(static_1.isNull(usersTable.phone)).all();
+        const notEqSelect = usersTable.select().where(static_1.notEq(usersTable.phone, 'hello')).all();
+        // ordered select
+        const ordered = await usersTable.select().orderBy((table) => table.phone, order_1.default.ASC).all();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/docs/cases/simple_update.d.ts

@@ -0,0 +1 @@
+export {};

package/docs/cases/simple_update.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+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()
+            .connectionString('postgresql://postgres@127.0.0.1/drizzle')
+            .connect();
+        const usersTable = new usersTable_1.default(db);
+        const citiesTable = new citiesTable_1.default(db);
+        const userGroupsTable = new userGroupsTable_1.default(db);
+        await usersTable.update()
+            .where(builders_1.eq(usersTable.phone, 'hello'))
+            .set({ fullName: 'newName' })
+            .execute();
+        const updatedCities = await citiesTable.update()
+            .where(builders_1.eq(citiesTable.location, 'USA'))
+            .set({ metadata: { population: 1, connection: 'first' } })
+            .all();
+        const updatedUserGroup = await userGroupsTable.update()
+            .where(builders_1.eq(userGroupsTable.id, 1))
+            .set({ description: 'updated description' })
+            .first();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();