drizzle-orm 0.9.0 → 0.9.4

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);
+    }
+})();

package/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("../../columns/column").IndexedColumn<import("../..").PgInteger, true, true>;
+    foundationDate: import("../../columns/column").Column<import("../..").PgTimestamp, false, false>;
+    location: import("../../columns/column").Column<import("../..").PgVarChar, true, false>;
+    userId: import("../../columns/column").Column<import("../..").PgInteger, true, false>;
+    metadata: import("../../columns/column").Column<import("../..").PgJsonb<CityMeta>, true, false>;
+    tableName(): string;
+}
+export {};

package/docs/tables/citiesTable.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const column_1 = require("../../columns/column");
+const abstractTable_1 = require("../../tables/abstractTable");
+const usersTable_1 = require("./usersTable");
+class CitiesTable extends abstractTable_1.default {
+    constructor() {
+        super(...arguments);
+        this.id = this.int('id').autoIncrement().primaryKey();
+        this.foundationDate = this.timestamp('name', { notNull: true });
+        this.location = this.varchar('page', { size: 256 });
+        this.userId = this.int('user_id').foreignKey(usersTable_1.default, (table) => table.id, column_1.OnDelete.CASCADE);
+        this.metadata = this.jsonb('metadata');
+    }
+    tableName() {
+        return 'cities';
+    }
+}
+exports.default = CitiesTable;

package/docs/tables/citiesToUsers.d.ts

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

package/docs/tables/citiesToUsers.js

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

package/docs/tables/userGroupsTable.d.ts

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

package/docs/tables/userGroupsTable.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractTable_1 = require("../../tables/abstractTable");
+class UserGroupsTable extends abstractTable_1.default {
+    constructor() {
+        super(...arguments);
+        this.id = this.int('id').autoIncrement().primaryKey();
+        this.name = this.varchar('name');
+        this.description = this.varchar('description');
+    }
+    tableName() {
+        return 'user_groups';
+    }
+}
+exports.default = UserGroupsTable;

package/docs/tables/usersTable.d.ts

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

package/docs/tables/usersTable.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rolesEnum = void 0;
+/* eslint-disable max-classes-per-file */
+const abstractTable_1 = require("../../tables/abstractTable");
+const type_1 = require("../../types/type");
+// import { rolesEnum } from '../types/rolesType';
+exports.rolesEnum = type_1.createEnum({ alias: 'test-enum', values: ['user', 'guest', 'admin'] });
+class UsersTable extends abstractTable_1.default {
+    constructor() {
+        super(...arguments);
+        this.id = this.int('id').autoIncrement().primaryKey();
+        this.fullName = this.text('full_name');
+        this.phone = this.varchar('phone', { size: 256 });
+        this.media = this.jsonb('media');
+        this.decimalField = this.decimal('test', { notNull: true, precision: 100, scale: 2 });
+        this.bigIntField = this.bigint('test1');
+        this.role = this.type(exports.rolesEnum, 'name_in_table', { notNull: true });
+        this.createdAt = this.timestamp('created_at', { notNull: true });
+        this.updatedAt = this.timestamp('updated_at');
+        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/docs/tables/usersToUserGroups.d.ts

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

package/docs/tables/usersToUserGroups.js

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

package/docs/types/rolesType.d.ts

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

package/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/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/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/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/errors/builderError.js

@@ -0,0 +1,24 @@
+"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() : 'undefined'}
+Column names: ${columns.map((column) => column.getColumnName()).join(', ')}\n-----\n`;
+    }
+}
+exports.default = BuilderError;

package/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/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/index.d.ts

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

package/index.js

@@ -0,0 +1,32 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drizzle = void 0;
+const create_1 = require("./builders/lowLvlBuilders/create");
+const db_1 = require("./db");
+const migrator_1 = require("./migrator/migrator");
+__exportStar(require("./db"), exports);
+__exportStar(require("./builders"), exports);
+__exportStar(require("./columns"), exports);
+__exportStar(require("./tables"), exports);
+exports.drizzle = {
+    prepareCreateTable(table) {
+        return create_1.default.table(table).build();
+    },
+    migrator(db) {
+        return new migrator_1.default(db);
+    },
+    async connect(config) {
+        const dbConnector = new db_1.DbConnector().params(config);
+        return dbConnector.connect();
+    },
+};

package/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/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/logger/abstractLogger.d.ts

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

package/logger/abstractLogger.js

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

package/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/logger/consoleLogger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractLogger_1 = require("./abstractLogger");
+class ConsoleLogger extends abstractLogger_1.default {
+    info(msg) {
+        console.log(`INFO: ${msg}`);
+    }
+    error(msg) {
+        console.log(`ERROR: ${msg}`);
+    }
+}
+exports.default = ConsoleLogger;

package/mappers/index.js

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

package/mappers/responseMapper.d.ts

@@ -0,0 +1,7 @@
+import { QueryResult } from 'pg';
+import { AbstractColumn } from '../columns/column';
+import ColumnType from '../columns/types/columnType';
+import { ExtractModel } from '../tables/inferTypes';
+export default class QueryResponseMapper {
+    static map: <ITable>(mappedServiceToDb: { [name in keyof ExtractModel<ITable>]: AbstractColumn<ColumnType<{}>, true, false>; }, queryResult: QueryResult<any>) => (ExtractModel<ITable> | undefined)[];
+}

package/mappers/responseMapper.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line max-len
+const checkProperties = (obj) => Object.values(obj).every((x) => x === null || Number.isNaN(x));
+class QueryResponseMapper {
+}
+exports.default = QueryResponseMapper;
+QueryResponseMapper.map = (mappedServiceToDb, queryResult) => {
+    const response = [];
+    queryResult.rows.forEach((row) => {
+        const mappedRow = {};
+        Object.keys(mappedServiceToDb).forEach((key) => {
+            const column = mappedServiceToDb[key];
+            const value = column.getColumnType().selectStrategy(row[column.getAlias()]);
+            mappedRow[key] = value;
+        });
+        if (checkProperties(mappedRow)) {
+            response.push(undefined);
+        }
+        response.push(mappedRow);
+    });
+    return response;
+};

package/migrator/index.js

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

package/migrator/migrator.d.ts

@@ -0,0 +1,16 @@
+import Db from '../db/db';
+export declare class MigrationSession {
+    private finalQuery;
+    execute: (query: string) => void;
+    getQuery: () => string;
+}
+export default class Migrator {
+    private _db;
+    private migrationsPerVersion;
+    private session;
+    constructor(db: Db);
+    chain: (tag: number, migration: (dbSession: MigrationSession) => void) => Migrator;
+    getResultScript: () => string[];
+    execute: () => Promise<boolean>;
+    private generateHash;
+}