drizzle-orm 0.10.26 → 0.10.29

package/dist/db/dbStringConnector.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pg_1 = require("pg");
+const db_1 = __importDefault(require("./db"));
+const session_1 = __importDefault(require("./session"));
+class DBStringConnector {
+    constructor(url) {
+        this.connect = async () => {
+            const config = {
+                connectionString: this._url,
+            };
+            try {
+                const pool = new pg_1.Pool(config);
+                await pool.connect();
+                // console.log('Db connected!');
+                return new db_1.default(new session_1.default(pool));
+            }
+            catch (e) {
+                // console.log(`Connection error: ${e.message}`);
+                throw new Error(`Connection error: ${e.message}`);
+            }
+        };
+        this._url = url;
+    }
+}
+exports.default = DBStringConnector;

package/dist/db/group_by.js

@@ -0,0 +1,68 @@
+"use strict";
+// const _groupBy = <T, K extends keyof any>(list: T[], getKey: (item: T) => K) => {
+//   list.reduce((previous, currentItem) => {
+//     const group = getKey(currentItem);
+//     // eslint-disable-next-line no-param-reassign
+//     if (!previous[group]) previous[group] = [];
+//     previous[group].push(currentItem);
+//     return previous;
+//   }, {} as Record<K, T[]>);
+// };
+// const groupBy = (xs, key) => xs.reduce((rv, x) => {
+//   (rv[x[key]] = rv[x[key]] || []).push(x);
+//   return rv;
+// }, {});
+// interface Mapp {
+//   [key: string]: any;
+// }
+// const groupBy1 = <K, V>(list: Array<K>, keyGetter: (input: V) => K): Map<K, Array<V>> => {
+//   const map = new Map<K, Array<V>>();
+//   list.forEach((item) => {
+//     const key = keyGetter(item as unknown as V);
+//     const collection = map.get(key);
+//     console.log(collection);
+//     console.log(map.has(key));
+//     if (!collection) {
+//       map.set(key, [item as unknown as V]);
+//     } else {
+//       collection.push(item as unknown as V);
+//     }
+//   });
+//   return map;
+// };
+// interface T1 {
+//   name: string,
+//   key: number
+// }
+// interface T2 {
+//   name: string,
+//   hello: number
+// }
+// interface Person {
+//   t1: T1,
+//   t2: T2
+// }
+// const person: Person[] = [
+//   {
+//     t1: {
+//       name: 'name',
+//       key: 2,
+//     },
+//     t2: {
+//       name: 'name',
+//       hello: 2,
+//     },
+//   },
+//   {
+//     t1: {
+//       name: 'name',
+//       key: 2,
+//     },
+//     t2: {
+//       name: 'name3',
+//       hello: 3,
+//     },
+//   },
+// ];
+// const d = groupBy1(person, (i: Person) => i.t1);
+// console.log(d);

package/dist/db/index.d.ts

@@ -0,0 +1,4 @@
+export { default as DB } from './db';
+export { default as DbConnector } from './dbConnector';
+export { default as DBStringConnector } from './dbStringConnector';
+export { ISession } from './session';

package/dist/db/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISession = exports.DBStringConnector = exports.DbConnector = exports.DB = void 0;
+var db_1 = require("./db");
+Object.defineProperty(exports, "DB", { enumerable: true, get: function () { return __importDefault(db_1).default; } });
+var dbConnector_1 = require("./dbConnector");
+Object.defineProperty(exports, "DbConnector", { enumerable: true, get: function () { return __importDefault(dbConnector_1).default; } });
+var dbStringConnector_1 = require("./dbStringConnector");
+Object.defineProperty(exports, "DBStringConnector", { enumerable: true, get: function () { return __importDefault(dbStringConnector_1).default; } });
+var session_1 = require("./session");
+Object.defineProperty(exports, "ISession", { enumerable: true, get: function () { return session_1.ISession; } });

package/dist/db/session.d.ts

@@ -0,0 +1,9 @@
+import { Pool, QueryResult } from 'pg';
+export declare abstract class ISession {
+    abstract execute(query: string, values?: Array<any>): Promise<QueryResult<any>>;
+}
+export default class Session extends ISession {
+    private pool;
+    constructor(pool: Pool);
+    execute(query: string, values?: Array<any>): Promise<QueryResult<any>>;
+}

package/dist/db/session.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISession = void 0;
+class ISession {
+}
+exports.ISession = ISession;
+class Session extends ISession {
+    constructor(pool) {
+        super();
+        this.pool = pool;
+    }
+    async execute(query, values) {
+        return this.pool.query(query, values || []);
+    }
+}
+exports.default = Session;

package/dist/docs/cases/simple_delete.d.ts

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

package/dist/docs/cases/simple_delete.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+const consoleLogger_1 = __importDefault(require("../../logger/consoleLogger"));
+const citiesTable_1 = __importDefault(require("../tables/citiesTable"));
+const userGroupsTable_1 = __importDefault(require("../tables/userGroupsTable"));
+const usersTable_1 = __importDefault(require("../tables/usersTable"));
+(async () => {
+    try {
+        const db = await new __1.DbConnector()
+            .connectionString('postgresql://postgres@127.0.0.1/migrator')
+            .connect();
+        db.useLogger(new consoleLogger_1.default());
+        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, 6))
+            .execute();
+        const deletedCities = await citiesTable.delete()
+            .where(builders_1.eq(citiesTable.id, 7))
+            .all();
+        const deletedUserGroup = await userGroupsTable.delete()
+            .where(builders_1.eq(userGroupsTable.id, 3))
+            .findOne();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/dist/docs/cases/simple_insert.d.ts

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

package/dist/docs/cases/simple_insert.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dbConnector_1 = __importDefault(require("../../db/dbConnector"));
+const consoleLogger_1 = __importDefault(require("../../logger/consoleLogger"));
+const citiesTable_1 = __importDefault(require("../tables/citiesTable"));
+const userGroupsTable_1 = __importDefault(require("../tables/userGroupsTable"));
+const usersTable_1 = __importDefault(require("../tables/usersTable"));
+(async () => {
+    try {
+        const db = await new dbConnector_1.default()
+            .connectionString('postgresql://postgres@127.0.0.1/migrator')
+            .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(Create.table(usersTable).build());
+        // await db.session().execute(Create.table(citiesTable).build());
+        // await db.session().execute(Create.table(userGroupsTable).build());
+        db.useLogger(new consoleLogger_1.default());
+        await usersTable.insert({
+            decimalField: 12.4,
+            createdAt: new Date(),
+            role: 'foo',
+        }).execute();
+        const insertedCities = await citiesTable.insert({
+            foundationDate: new Date(),
+        }).all();
+        const insertedUserGroup = await userGroupsTable.insert({
+            name: 'firstGroup',
+        }).findOne();
+        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: 'foo',
+            }, {
+                decimalField: 32.4,
+                createdAt: new Date(),
+                role: 'foo',
+                phone: '+1808',
+            }])
+            .onConflict((table) => table.phoneIndex, { isArchived: true }).all();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/dist/docs/cases/simple_join.d.ts

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

package/dist/docs/cases/simple_join.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable max-len */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+const consoleLogger_1 = __importDefault(require("../../logger/consoleLogger"));
+const citiesTable_1 = __importDefault(require("../tables/citiesTable"));
+const userGroupsTable_1 = __importDefault(require("../tables/userGroupsTable"));
+const usersTable_1 = __importDefault(require("../tables/usersTable"));
+const usersToUserGroups_1 = __importDefault(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/migrator')
+            .connect();
+        db.useLogger(new consoleLogger_1.default());
+        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(Create.table(usersTable).build());
+        // await db.session().execute(Create.table(citiesTable).build());
+        // await db.session().execute(Create.table(userGroupsTable).build());
+        // await db.session().execute(Create.table(usersToUserGroupsTable).build());
+        const userRes = await usersTable.insertMany([{
+                decimalField: 4.2,
+                createdAt: new Date(),
+                role: 'foo',
+            }, {
+                decimalField: 5.8,
+                createdAt: new Date(),
+                role: 'foo',
+            }]).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;
+        // });
+        // const usersTable = new UsersTable(db);
+        // const citiesTable = new CitiesTable(db);
+        const sdf = await citiesTable.select({
+            id: citiesTable.id,
+            userId: citiesTable.userId,
+        }).where(builders_1.eq(citiesTable.id, 1))
+            .leftJoin(usersTable_1.default, (city) => city.userId, (users) => users.id, {
+            id: usersTable.id,
+        })
+            .execute();
+        // group case
+        const usersWithUserGroups = await usersToUserGroupsTable.select()
+            .where(builders_1.eq(userGroupsTable.id, 1))
+            .leftJoin(usersTable_1.default, (userToGroup) => userToGroup.userId, (users) => users.id, {
+            id: usersTable.id,
+        })
+            .leftJoin(usersToUserGroups_1.default, userGroupsTable_1.default, (userToGroup) => userToGroup.groupId, (userGroup) => userGroup.id, {
+            id: userGroupsTable.id,
+        })
+            .execute();
+        const userGroupWithUsers = usersWithUserGroups.group({
+            one: (_, dbUser, dbUserGroup) => dbUser,
+            many: (_, dbUser, dbUserGroup) => dbUserGroup,
+        });
+        // const userWithGroups: ExtractModel<UsersTable> & { groups: ExtractModel<UserGroupsTable>[] } = {
+        //   ...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/dist/docs/cases/simple_select.d.ts

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

package/dist/docs/cases/simple_select.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+const order_1 = __importDefault(require("../../builders/highLvlBuilders/order"));
+const static_1 = require("../../builders/requestBuilders/where/static");
+const consoleLogger_1 = __importDefault(require("../../logger/consoleLogger"));
+const usersTable_1 = __importDefault(require("../tables/usersTable"));
+(async () => {
+    try {
+        const db = await new __1.DbConnector()
+            .connectionString('postgresql://postgres@127.0.0.1/migrator')
+            .connect();
+        const usersTable = new usersTable_1.default(db);
+        db.useLogger(new consoleLogger_1.default());
+        // select all
+        const allSelect = await usersTable.select().all();
+        // select first
+        const firstSelect = await usersTable.select().all();
+        // 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(20).offset(20).all();
+        const likeSelect = await usersTable.select().where(builders_1.like(usersTable.phone, 'hello')).all();
+        const inArraySelect = await usersTable.select().where(static_1.inArray(usersTable.phone, ['hello'])).all();
+        const greaterSelect = await usersTable.select().where(static_1.greater(usersTable.bigIntField, 3)).all();
+        const lessSelect = await usersTable.select().where(static_1.less(usersTable.bigIntField, 3)).all();
+        const greaterEqSelect = await usersTable.select().where(static_1.greaterEq(usersTable.bigIntField, 3))
+            .all();
+        const lessEqSelect = await usersTable.select().where(static_1.lessEq(usersTable.bigIntField, 3));
+        const isNullSelect = await usersTable.select().where(static_1.isNull(usersTable.phone)).all();
+        const notEqSelect = await usersTable.select().where(static_1.notEq(usersTable.phone, 'hello')).all();
+        const partialSelect = await usersTable.select({
+            mappedId: usersTable.id,
+            mappedPhone: usersTable.phone,
+        }).all();
+        // const { mappedId, mappedPhone } = partialSelect;
+        // ordered select
+        const ordered = await usersTable.select().orderBy((table) => table.phone, order_1.default.ASC).all();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/dist/docs/cases/simple_update.d.ts

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

package/dist/docs/cases/simple_update.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const __1 = require("../..");
+const builders_1 = require("../../builders");
+const consoleLogger_1 = __importDefault(require("../../logger/consoleLogger"));
+const citiesTable_1 = __importDefault(require("../tables/citiesTable"));
+const userGroupsTable_1 = __importDefault(require("../tables/userGroupsTable"));
+const usersTable_1 = __importDefault(require("../tables/usersTable"));
+(async () => {
+    try {
+        const db = await new __1.DbConnector()
+            .connectionString('postgresql://postgres@127.0.0.1/migrator')
+            .connect();
+        db.useLogger(new consoleLogger_1.default());
+        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();
+        console.log(updatedCities);
+        const updatedUserGroup = await userGroupsTable.update()
+            .where(builders_1.eq(userGroupsTable.id, 1))
+            .set({ description: 'updated description' })
+            .all();
+    }
+    catch (e) {
+        console.log(e);
+    }
+})();

package/dist/docs/tables/citiesTable.d.ts

@@ -0,0 +1,14 @@
+import AbstractTable from '../../tables/abstractTable';
+interface CityMeta {
+    population: number;
+    connection: string;
+}
+export default class CitiesTable extends AbstractTable<CitiesTable> {
+    id: import("../..").Column<import("../../columns/types/pgSerial").default, true, true, this>;
+    foundationDate: import("../..").Column<import("../..").PgTimestamp, false, false, this>;
+    location: import("../..").Column<import("../..").PgVarChar, true, false, this>;
+    userId: import("../..").Column<import("../..").PgInteger, true, false, this>;
+    metadata: import("../..").Column<import("../..").PgJsonb<CityMeta>, true, false, this>;
+    tableName(): string;
+}
+export {};

package/dist/docs/tables/citiesTable.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractTable_1 = __importDefault(require("../../tables/abstractTable"));
+const usersTable_1 = __importDefault(require("./usersTable"));
+class CitiesTable extends abstractTable_1.default {
+    constructor() {
+        super(...arguments);
+        this.id = this.serial('id').primaryKey();
+        this.foundationDate = this.timestamp('name').notNull();
+        this.location = this.varchar('page', { size: 256 });
+        this.userId = this.int('user_id').foreignKey(usersTable_1.default, (table) => table.id, { onUpdate: 'CASCADE' });
+        this.metadata = this.jsonb('metadata');
+    }
+    tableName() {
+        return 'cities';
+    }
+}
+exports.default = CitiesTable;

package/dist/docs/tables/userGroupsTable.d.ts

@@ -0,0 +1,7 @@
+import AbstractTable from '../../tables/abstractTable';
+export default class UserGroupsTable extends AbstractTable<UserGroupsTable> {
+    id: import("../..").Column<import("../../columns/types/pgSerial").default, true, true, this>;
+    name: import("../..").Column<import("../..").PgVarChar, true, false, this>;
+    description: import("../..").Column<import("../..").PgVarChar, true, false, this>;
+    tableName(): string;
+}

package/dist/docs/tables/userGroupsTable.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractTable_1 = __importDefault(require("../../tables/abstractTable"));
+class UserGroupsTable extends abstractTable_1.default {
+    constructor() {
+        super(...arguments);
+        this.id = this.serial('id').primaryKey();
+        this.name = this.varchar('name');
+        this.description = this.varchar('description');
+    }
+    tableName() {
+        return 'user_groups';
+    }
+}
+exports.default = UserGroupsTable;

package/dist/docs/tables/usersTable.d.ts

@@ -0,0 +1,17 @@
+import AbstractTable from '../../tables/abstractTable';
+export declare const rolesEnum: import("../../types/type").default<"foo" | "bar" | "baz">;
+export default class UsersTable extends AbstractTable<UsersTable> {
+    id: import("../../columns/column").Column<import("../../columns/types/pgSerial").default, true, true, this>;
+    fullName: import("../../columns/column").Column<import("../..").PgText, true, false, this>;
+    phone: import("../../columns/column").Column<import("../..").PgVarChar, true, false, this>;
+    media: import("../../columns/column").Column<import("../..").PgJsonb<string[]>, true, false, this>;
+    decimalField: import("../../columns/column").Column<import("../..").PgBigDecimal, false, false, this>;
+    bigIntField: import("../../columns/column").Column<import("../..").PgBigInt, true, false, this>;
+    role: import("../../columns/column").Column<import("../../columns/types/pgEnum").default<"foo" | "bar" | "baz">, false, false, this>;
+    createdAt: import("../../columns/column").Column<import("../..").PgTimestamp, false, false, this>;
+    updatedAt: import("../../columns/column").Column<import("../..").PgTimestamp, true, false, this>;
+    isArchived: import("../../columns/column").Column<import("../..").PgBoolean, true, false, this>;
+    phoneFullNameIndex: import("../../indexes/tableIndex").default;
+    phoneIndex: import("../../indexes/tableIndex").default;
+    tableName(): string;
+}

package/dist/docs/tables/usersTable.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rolesEnum = void 0;
+/* eslint-disable max-classes-per-file */
+// import { Defaults } from '../../columns/column';
+const column_1 = require("../../columns/column");
+const abstractTable_1 = __importDefault(require("../../tables/abstractTable"));
+const type_1 = require("../../types/type");
+// import { rolesEnum } from '../types/rolesType';
+exports.rolesEnum = type_1.createEnum({ alias: 'test-enum', values: ['foo', 'bar', 'baz'] });
+class UsersTable extends abstractTable_1.default {
+    constructor() {
+        super(...arguments);
+        this.id = this.serial('id').primaryKey();
+        this.fullName = this.text('full_name');
+        this.phone = this.varchar('phone', { size: 256 });
+        this.media = this.jsonb('media');
+        this.decimalField = this.decimal('test', { precision: 100, scale: 2 }).notNull();
+        this.bigIntField = this.bigint('test1', 'max_bytes_53');
+        this.role = this.type(exports.rolesEnum, 'name_in_table').notNull();
+        this.createdAt = this.timestamp('created_at').notNull();
+        // public createdAtWithTimezone = this.timestamptz('created_at');
+        this.updatedAt = this.timestamp('updated_at').defaultValue(column_1.Defaults.CURRENT_TIMESTAMP);
+        this.isArchived = this.bool('is_archived').defaultValue(false);
+        this.phoneFullNameIndex = this.index([this.phone, this.fullName]);
+        this.phoneIndex = this.uniqueIndex(this.phone);
+    }
+    tableName() {
+        return 'users';
+    }
+}
+exports.default = UsersTable;

package/dist/docs/tables/usersToUserGroups.d.ts

@@ -0,0 +1,7 @@
+import AbstractTable from '../../tables/abstractTable';
+export default class UsersToUserGroupsTable extends AbstractTable<UsersToUserGroupsTable> {
+    groupId: import("../..").Column<import("../..").PgInteger, true, false, this>;
+    userId: import("../..").Column<import("../..").PgInteger, true, false, this>;
+    manyToManyIndex: import("../../indexes/tableIndex").default;
+    tableName(): string;
+}

package/dist/docs/tables/usersToUserGroups.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractTable_1 = __importDefault(require("../../tables/abstractTable"));
+const userGroupsTable_1 = __importDefault(require("./userGroupsTable"));
+const usersTable_1 = __importDefault(require("./usersTable"));
+class UsersToUserGroupsTable extends abstractTable_1.default {
+    constructor() {
+        super(...arguments);
+        this.groupId = this.int('city_id').foreignKey(userGroupsTable_1.default, (table) => table.id, { onDelete: 'CASCADE' });
+        this.userId = this.int('user_id').foreignKey(usersTable_1.default, (table) => table.id, { onDelete: 'CASCADE' });
+        this.manyToManyIndex = this.index([this.groupId, this.userId]);
+    }
+    tableName() {
+        return 'users_to_user_groups';
+    }
+}
+exports.default = UsersToUserGroupsTable;

package/dist/docs/types/rolesType.d.ts

@@ -0,0 +1 @@
+export declare const rolesEnum: import("../../types/type").default<"foo" | "bar" | "baz">;

package/dist/docs/types/rolesType.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rolesEnum = void 0;
+const type_1 = require("../../types/type");
+// eslint-disable-next-line import/prefer-default-export
+exports.rolesEnum = type_1.createEnum({ alias: 'test-enum', values: ['foo', 'bar', 'baz'] });