drizzle-orm 0.10.21 → 0.10.24

package/dist/src/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/src/docs/cases/simple_select.d.ts

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

package/dist/src/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/src/docs/cases/simple_update.d.ts

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

package/dist/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/docs/types/rolesType.d.ts

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

package/dist/src/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'] });

package/dist/src/errors/baseError.d.ts

@@ -0,0 +1,22 @@
+export interface Failure {
+    type: PgSessionError;
+    reason: Error;
+}
+export declare enum PgSessionError {
+    PgQueryExecutionError = 0
+}
+export declare type Either<L, A> = Left<L, A> | Right<L, A>;
+export declare class Left<L, A> {
+    readonly value: L;
+    constructor(value: L);
+    isLeft(): this is Left<L, A>;
+    isRight(): this is Right<L, A>;
+}
+export declare class Right<L, A> {
+    readonly value: A;
+    constructor(value: A);
+    isLeft(): this is Left<L, A>;
+    isRight(): this is Right<L, A>;
+}
+export declare const left: <L, A>(l: L) => Either<L, A>;
+export declare const right: <L, A>(a: A) => Either<L, A>;

package/dist/src/errors/baseError.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.right = exports.left = exports.Right = exports.Left = exports.PgSessionError = void 0;
+var PgSessionError;
+(function (PgSessionError) {
+    PgSessionError[PgSessionError["PgQueryExecutionError"] = 0] = "PgQueryExecutionError";
+})(PgSessionError = exports.PgSessionError || (exports.PgSessionError = {}));
+class Left {
+    constructor(value) {
+        this.value = value;
+    }
+    isLeft() {
+        return true;
+    }
+    isRight() {
+        return false;
+    }
+}
+exports.Left = Left;
+class Right {
+    constructor(value) {
+        this.value = value;
+    }
+    isLeft() {
+        return false;
+    }
+    isRight() {
+        return true;
+    }
+}
+exports.Right = Right;
+const left = (l) => new Left(l);
+exports.left = left;
+const right = (a) => new Right(a);
+exports.right = right;

package/dist/src/errors/builderError.d.ts

@@ -0,0 +1,14 @@
+import Expr from '../builders/requestBuilders/where/where';
+import { AbstractColumn } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+export declare enum BuilderType {
+    SELECT = 0,
+    JOINED_SELECT = 1,
+    TWO_JOINED_SELECT = 2,
+    DELETE = 3,
+    INSERT = 4,
+    UPDATE = 5
+}
+export default class BuilderError extends Error {
+    constructor(builderType: BuilderType, tableName: string, columns: AbstractColumn<ColumnType>[], reason: Error, filter?: Expr);
+}

package/dist/src/errors/builderError.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuilderType = void 0;
+var BuilderType;
+(function (BuilderType) {
+    BuilderType[BuilderType["SELECT"] = 0] = "SELECT";
+    BuilderType[BuilderType["JOINED_SELECT"] = 1] = "JOINED_SELECT";
+    BuilderType[BuilderType["TWO_JOINED_SELECT"] = 2] = "TWO_JOINED_SELECT";
+    BuilderType[BuilderType["DELETE"] = 3] = "DELETE";
+    BuilderType[BuilderType["INSERT"] = 4] = "INSERT";
+    BuilderType[BuilderType["UPDATE"] = 5] = "UPDATE";
+})(BuilderType = exports.BuilderType || (exports.BuilderType = {}));
+class BuilderError extends Error {
+    constructor(builderType, tableName, columns, reason, filter) {
+        super('');
+        this.message = ` Error while building select query from ${tableName}\n-----\nIf you see current error, please create [github issue](https://github.com/lambda-direct/drizzle-orm/issues) and provide following information\n
+Reason: ${reason.message}
+Query builder: ${BuilderType[builderType]}
+Table name: ${tableName}
+Filter query: ${filter ? filter.toQuery().query : 'undefined'}
+Values: ${filter ? filter.toQuery().values : 'undefined'}
+Column names: ${columns.map((column) => column.getColumnName()).join(', ')}\n-----\n`;
+    }
+}
+exports.default = BuilderError;

package/dist/src/errors/dbErrors.d.ts

@@ -0,0 +1,12 @@
+export declare class DatabaseSelectError extends Error {
+    constructor(tableName: string, reason: Error, query: string);
+}
+export declare class DatabaseDeleteError extends Error {
+    constructor(tableName: string, reason: Error, query: string);
+}
+export declare class DatabaseInsertError extends Error {
+    constructor(tableName: string, reason: Error, query: string);
+}
+export declare class DatabaseUpdateError extends Error {
+    constructor(tableName: string, reason: Error, query: string);
+}

package/dist/src/errors/dbErrors.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseUpdateError = exports.DatabaseInsertError = exports.DatabaseDeleteError = exports.DatabaseSelectError = void 0;
+/* eslint-disable max-classes-per-file */
+class DatabaseSelectError extends Error {
+    constructor(tableName, reason, query) {
+        super(` Got an error, while selecting from ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+    }
+}
+exports.DatabaseSelectError = DatabaseSelectError;
+class DatabaseDeleteError extends Error {
+    constructor(tableName, reason, query) {
+        super(` Got an error, while deleting from ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+    }
+}
+exports.DatabaseDeleteError = DatabaseDeleteError;
+class DatabaseInsertError extends Error {
+    constructor(tableName, reason, query) {
+        super(` Got an error, while inserting to ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+    }
+}
+exports.DatabaseInsertError = DatabaseInsertError;
+class DatabaseUpdateError extends Error {
+    constructor(tableName, reason, query) {
+        super(` Got an error, while updating ${tableName}. Reason: ${reason.message}. Query to database looks like:\n${query}\n`);
+    }
+}
+exports.DatabaseUpdateError = DatabaseUpdateError;

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+import { ClientConfig } from 'pg';
+import { DB } from './db';
+import Migrator from './migrator/migrator';
+export * from './db';
+export * from './builders';
+export * from './columns';
+export * from './tables';
+export declare const drizzle: {
+    connect(config: ClientConfig): Promise<DB>;
+    migrator(db: DB): Migrator;
+};

package/dist/src/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drizzle = void 0;
+const db_1 = require("./db");
+const migrator_1 = __importDefault(require("./migrator/migrator"));
+__exportStar(require("./db"), exports);
+__exportStar(require("./builders"), exports);
+__exportStar(require("./columns"), exports);
+__exportStar(require("./tables"), exports);
+exports.drizzle = {
+    async connect(config) {
+        const dbConnector = new db_1.DbConnector().params(config);
+        return dbConnector.connect();
+    },
+    migrator(db) {
+        return new migrator_1.default(db);
+    },
+};

package/dist/src/indexes/tableIndex.d.ts

@@ -0,0 +1,11 @@
+import { Column } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+export default class TableIndex {
+    private _columns;
+    private _tableName;
+    private _isUnique;
+    constructor(tableName: string, columns: Column<ColumnType<any>, boolean, boolean>[], isUnique?: boolean);
+    getColumns: () => Column<ColumnType<any>, boolean, boolean>[];
+    indexName: () => string;
+    isUnique: () => boolean;
+}

package/dist/src/indexes/tableIndex.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TableIndex {
+    constructor(tableName, columns, isUnique = false) {
+        this._columns = [];
+        this.getColumns = () => this._columns;
+        this.indexName = () => {
+            const columnNames = this._columns.map((column) => column.getColumnName());
+            return `${this._tableName}_${columnNames.join('_')}_index`;
+        };
+        this.isUnique = () => this._isUnique;
+        this._columns = columns;
+        this._tableName = tableName;
+        this._isUnique = isUnique;
+    }
+}
+exports.default = TableIndex;

package/dist/src/logger/abstractLogger.d.ts

@@ -0,0 +1,4 @@
+export default abstract class BaseLogger {
+    abstract info(msg: string): void;
+    abstract error(msg: string): void;
+}

package/dist/src/logger/abstractLogger.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class BaseLogger {
+}
+exports.default = BaseLogger;

package/dist/src/logger/consoleLogger.d.ts

@@ -0,0 +1,5 @@
+import BaseLogger from './abstractLogger';
+export default class ConsoleLogger extends BaseLogger {
+    info(msg: string): void;
+    error(msg: string): void;
+}

package/dist/src/logger/consoleLogger.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractLogger_1 = __importDefault(require("./abstractLogger"));
+class ConsoleLogger extends abstractLogger_1.default {
+    info(msg) {
+        console.log(`INFO: ${msg}`);
+    }
+    error(msg) {
+        console.log(`ERROR: ${msg}`);
+    }
+}
+exports.default = ConsoleLogger;

package/dist/src/mappers/index.js

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