@spinajs/orm 2.0.45 → 2.0.48

package/lib/builders.js

@@ -1,66 +1,30 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var RawQuery_1, WhereBuilder_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaQueryBuilder = exports.ScheduleQueryBuilder = exports.DropEventQueryBuilder = exports.EventQueryBuilder = exports.EventIntervalDesc = exports.CloneTableQueryBuilder = exports.TruncateTableQueryBuilder = exports.TableQueryBuilder = exports.AlterTableQueryBuilder = exports.DropTableQueryBuilder = exports.TableExistsQueryBuilder = exports.AlterColumnQueryBuilder = exports.ColumnQueryBuilder = exports.ForeignKeyBuilder = exports.IndexQueryBuilder = exports.InsertQueryBuilder = exports.UpdateQueryBuilder = exports.OnDuplicateQueryBuilder = exports.DeleteQueryBuilder = exports.SelectQueryBuilderC = exports.SelectQueryBuilder = exports.WhereBuilder = exports.WithRecursiveBuilder = exports.JoinBuilder = exports.GroupByBuilder = exports.RawQuery = exports.ColumnsBuilder = exports.OrderByBuilder = exports.LimitBuilder = exports.QueryBuilder = exports.Builder = void 0;
+var RawQuery_1, WhereBuilder_1, SelectQueryBuilder_1;
 /* eslint-disable prettier/prettier */
-const di_1 = require("@spinajs/di");
-const exceptions_1 = require("@spinajs/exceptions");
-const exceptions_2 = require("./exceptions");
-const _ = __importStar(require("lodash"));
-const typescript_mix_1 = require("typescript-mix");
-const enums_1 = require("./enums");
-const interfaces_1 = require("./interfaces");
-const statements_1 = require("./statements");
-const driver_1 = require("./driver");
-const model_1 = require("./model");
-const relations_1 = require("./relations");
-const orm_1 = require("./orm");
+import { Container, Inject, NewInstance, DI, Injectable } from '@spinajs/di';
+import { InvalidArgument, MethodNotImplemented, InvalidOperation } from '../../exceptions/lib/index.js';
+import { OrmException } from './exceptions.js';
+import _ from 'lodash';
+import { use } from 'typescript-mix';
+import { ColumnMethods, ColumnType, QueryMethod, SordOrder, WhereBoolean, SqlOperator, JoinMethod } from './enums.js';
+import { DeleteQueryCompiler, InsertQueryCompiler, SelectQueryCompiler, TruncateTableQueryCompiler, TableQueryCompiler, AlterTableQueryCompiler, UpdateQueryCompiler, QueryContext, IndexQueryCompiler, RelationType, ReferentialAction, DefaultValueBuilder, ColumnAlterationType, TableExistsCompiler, DropTableCompiler, TableCloneQueryCompiler, QueryMiddleware, DropEventQueryCompiler, EventQueryCompiler } from './interfaces.js';
+import { BetweenStatement, ColumnMethodStatement, ColumnStatement, ExistsQueryStatement, InSetStatement, InStatement, RawQueryStatement, WhereQueryStatement, WhereStatement, ColumnRawStatement, JoinStatement, WithRecursiveStatement, GroupByStatement, Wrap } from './statements.js';
+import { OrmDriver } from './driver.js';
+import { extractModelDescriptor } from './model.js';
+import { BelongsToRelation, OneToManyRelation, ManyToManyRelation, BelongsToRecursiveRelation } from './relations.js';
+import { Orm } from './orm.js';
 function isWhereOperator(val) {
-    return _.isString(val) && Object.values(enums_1.SqlOperator).includes(val.toLowerCase());
+    return _.isString(val) && Object.values(SqlOperator).includes(val.toLowerCase());
 }
 let Builder = class Builder {
-    constructor(container, driver, model) {
-        this._middlewares = [];
-        this._queryMiddlewares = [];
-        this._driver = driver;
-        this._container = container;
-        this._model = model;
-        this._nonSelect = true;
-        this._asRaw = false;
-        this._queryMiddlewares = di_1.DI.resolve(Array.ofType(interfaces_1.QueryMiddleware));
-    }
     get Driver() {
         return this._driver;
     }
@@ -70,6 +34,16 @@ let Builder = class Builder {
     get Model() {
         return this._model;
     }
+    constructor(container, driver, model) {
+        this._middlewares = [];
+        this._queryMiddlewares = [];
+        this._driver = driver;
+        this._container = container;
+        this._model = model;
+        this._nonSelect = true;
+        this._asRaw = false;
+        this._queryMiddlewares = DI.resolve(Array.ofType(QueryMiddleware));
+    }
     then(onfulfilled, onrejected) {
         const execute = (compiled) => {
             return this._driver
@@ -144,15 +118,15 @@ let Builder = class Builder {
      * Builds query that is ready to use in DB
      */
     toDB() {
-        throw new exceptions_1.MethodNotImplemented();
+        throw new MethodNotImplemented();
     }
 };
 Builder = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [Object, driver_1.OrmDriver, Object])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, OrmDriver, Object])
 ], Builder);
-exports.Builder = Builder;
+export { Builder };
 /**
  * Base class for queires. Implements basic query functionality
  *
@@ -192,7 +166,7 @@ let QueryBuilder = class QueryBuilder extends Builder {
      */
     database(database) {
         if (!database) {
-            throw new exceptions_1.InvalidArgument(`schema argument cannot be null or empty`);
+            throw new InvalidArgument(`schema argument cannot be null or empty`);
         }
         this._database = database;
         return this;
@@ -210,7 +184,7 @@ let QueryBuilder = class QueryBuilder extends Builder {
      */
     setTable(table, alias) {
         if (!table.trim()) {
-            throw new exceptions_1.InvalidArgument('table name is empty');
+            throw new InvalidArgument('table name is empty');
         }
         this._table = table;
         this.setAlias(alias);
@@ -230,11 +204,11 @@ let QueryBuilder = class QueryBuilder extends Builder {
     }
 };
 QueryBuilder = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [Object, driver_1.OrmDriver, Object])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, OrmDriver, Object])
 ], QueryBuilder);
-exports.QueryBuilder = QueryBuilder;
+export { QueryBuilder };
 let LimitBuilder = class LimitBuilder {
     constructor() {
         this._first = false;
@@ -245,14 +219,14 @@ let LimitBuilder = class LimitBuilder {
     }
     take(count) {
         if (count <= 0) {
-            throw new exceptions_1.InvalidArgument(`take count cannot be negative number`);
+            throw new InvalidArgument(`take count cannot be negative number`);
         }
         this._limit.limit = count;
         return this;
     }
     skip(count) {
         if (count < 0) {
-            throw new exceptions_1.InvalidArgument(`skip count cannot be negative number`);
+            throw new InvalidArgument(`skip count cannot be negative number`);
         }
         this._limit.offset = count;
         return this;
@@ -263,7 +237,7 @@ let LimitBuilder = class LimitBuilder {
         return (await this);
     }
     async firstOrFail() {
-        return this.firstOrThrow(new exceptions_2.OrmException('not found'));
+        return this.firstOrThrow(new OrmException('not found'));
     }
     async orThrow(error) {
         const result = (await this);
@@ -284,15 +258,15 @@ let LimitBuilder = class LimitBuilder {
     }
 };
 LimitBuilder = __decorate([
-    (0, di_1.NewInstance)(),
+    NewInstance(),
     __metadata("design:paramtypes", [])
 ], LimitBuilder);
-exports.LimitBuilder = LimitBuilder;
+export { LimitBuilder };
 let OrderByBuilder = class OrderByBuilder {
     constructor() {
         this._sort = {
             column: '',
-            order: enums_1.SordOrder.ASC,
+            order: SordOrder.ASC,
         };
     }
     order(column, direction) {
@@ -305,14 +279,14 @@ let OrderByBuilder = class OrderByBuilder {
     orderBy(column) {
         this._sort = {
             column,
-            order: enums_1.SordOrder.ASC,
+            order: SordOrder.ASC,
         };
         return this;
     }
     orderByDescending(column) {
         this._sort = {
             column,
-            order: enums_1.SordOrder.DESC,
+            order: SordOrder.DESC,
         };
         return this;
     }
@@ -321,10 +295,10 @@ let OrderByBuilder = class OrderByBuilder {
     }
 };
 OrderByBuilder = __decorate([
-    (0, di_1.NewInstance)(),
+    NewInstance(),
     __metadata("design:paramtypes", [])
 ], OrderByBuilder);
-exports.OrderByBuilder = OrderByBuilder;
+export { OrderByBuilder };
 let ColumnsBuilder = class ColumnsBuilder {
     constructor() {
         this._columns = [];
@@ -342,24 +316,24 @@ let ColumnsBuilder = class ColumnsBuilder {
         return this;
     }
     columns(names) {
-        const descriptor = (0, model_1.extractModelDescriptor)(this._model);
+        const descriptor = extractModelDescriptor(this._model);
         this._columns = names.map((n) => {
-            return this._container.resolve(statements_1.ColumnStatement, [n, null, this._tableAlias, descriptor === null || descriptor === void 0 ? void 0 : descriptor.Columns.find((c) => c.Name === n)]);
+            return this._container.resolve(ColumnStatement, [n, null, this._tableAlias, descriptor?.Columns.find((c) => c.Name === n)]);
         });
         return this;
     }
     select(column, alias) {
-        const descriptor = (0, model_1.extractModelDescriptor)(this._model);
+        const descriptor = extractModelDescriptor(this._model);
         if (column instanceof Map) {
             column.forEach((alias, colName) => {
-                this._columns.push(this._container.resolve(statements_1.ColumnStatement, [colName, alias, this._tableAlias, descriptor === null || descriptor === void 0 ? void 0 : descriptor.Columns.find((c) => c.Name === colName)]));
+                this._columns.push(this._container.resolve(ColumnStatement, [colName, alias, this._tableAlias, descriptor?.Columns.find((c) => c.Name === colName)]));
             });
         }
         if (column instanceof RawQuery) {
-            this._columns.push(this._container.resolve(statements_1.ColumnRawStatement, [column, null, this._tableAlias]));
+            this._columns.push(this._container.resolve(ColumnRawStatement, [column, null, this._tableAlias]));
         }
         else {
-            this._columns.push(this._container.resolve(statements_1.ColumnStatement, [column, alias, this._tableAlias, descriptor === null || descriptor === void 0 ? void 0 : descriptor.Columns.find((c) => c.Name === column)]));
+            this._columns.push(this._container.resolve(ColumnStatement, [column, alias, this._tableAlias, descriptor?.Columns.find((c) => c.Name === column)]));
         }
         return this;
     }
@@ -368,17 +342,11 @@ let ColumnsBuilder = class ColumnsBuilder {
     }
 };
 ColumnsBuilder = __decorate([
-    (0, di_1.NewInstance)(),
+    NewInstance(),
     __metadata("design:paramtypes", [])
 ], ColumnsBuilder);
-exports.ColumnsBuilder = ColumnsBuilder;
+export { ColumnsBuilder };
 let RawQuery = RawQuery_1 = class RawQuery {
-    constructor(query, bindings) {
-        this._query = '';
-        this._bindings = [];
-        this._query = query;
-        this._bindings = bindings;
-    }
     get Query() {
         return this._query;
     }
@@ -388,13 +356,19 @@ let RawQuery = RawQuery_1 = class RawQuery {
     static create(query, bindings) {
         return new RawQuery_1(query, bindings);
     }
+    constructor(query, bindings) {
+        this._query = '';
+        this._bindings = [];
+        this._query = query;
+        this._bindings = bindings;
+    }
 };
 RawQuery = RawQuery_1 = __decorate([
-    (0, di_1.NewInstance)(),
+    NewInstance(),
     __metadata("design:paramtypes", [String, Array])
 ], RawQuery);
-exports.RawQuery = RawQuery;
-class GroupByBuilder {
+export { RawQuery };
+export class GroupByBuilder {
     constructor() {
         this._groupStatements = [];
     }
@@ -406,98 +380,96 @@ class GroupByBuilder {
         return this;
     }
     groupBy(expression) {
-        this._groupStatements.push(this._container.resolve(statements_1.GroupByStatement, [expression]));
+        this._groupStatements.push(this._container.resolve(GroupByStatement, [expression]));
         return this;
     }
 }
-exports.GroupByBuilder = GroupByBuilder;
-class JoinBuilder {
+export class JoinBuilder {
+    get JoinStatements() {
+        return this._joinStatements;
+    }
     constructor(container) {
         this._joinStatements = [];
         this._container = container;
         this._joinStatements = [];
     }
-    get JoinStatements() {
-        return this._joinStatements;
-    }
     clearJoins() {
         this._joinStatements = [];
         return this;
     }
     innerJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
-        this.addJoinStatement.call(this, enums_1.JoinMethod.INNER, ...arguments);
+        this.addJoinStatement.call(this, JoinMethod.INNER, ...arguments);
         return this;
     }
     leftJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
-        this.addJoinStatement.call(this, enums_1.JoinMethod.LEFT, ...arguments);
+        this.addJoinStatement.call(this, JoinMethod.LEFT, ...arguments);
         return this;
     }
     leftOuterJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
-        this.addJoinStatement.call(this, enums_1.JoinMethod.LEFT_OUTER, ...arguments);
+        this.addJoinStatement.call(this, JoinMethod.LEFT_OUTER, ...arguments);
         return this;
     }
     rightJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
-        this.addJoinStatement.call(this, enums_1.JoinMethod.RIGHT, ...arguments);
+        this.addJoinStatement.call(this, JoinMethod.RIGHT, ...arguments);
         return this;
     }
     rightOuterJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
-        this.addJoinStatement.call(this, enums_1.JoinMethod.RIGHT_OUTER, ...arguments);
+        this.addJoinStatement.call(this, JoinMethod.RIGHT_OUTER, ...arguments);
         return this;
     }
     fullOuterJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
-        this.addJoinStatement.call(this, enums_1.JoinMethod.FULL_OUTER, ...arguments);
+        this.addJoinStatement.call(this, JoinMethod.FULL_OUTER, ...arguments);
         return this;
     }
     crossJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
-        this.addJoinStatement.call(this, enums_1.JoinMethod.CROSS, ...arguments);
+        this.addJoinStatement.call(this, JoinMethod.CROSS, ...arguments);
         return this;
     }
     addJoinStatement(method, table, AliasOrForeignKey, fkOrPkKey, primaryKey) {
         let stmt = null;
         if (arguments.length === 3) {
-            stmt = this._container.resolve(statements_1.JoinStatement, [this, this._model, table, method, AliasOrForeignKey]);
+            stmt = this._container.resolve(JoinStatement, [this, this._model, table, method, AliasOrForeignKey]);
         }
         else if (arguments.length === 4) {
-            stmt = this._container.resolve(statements_1.JoinStatement, [this, this._model, table, method, AliasOrForeignKey, fkOrPkKey, null, this._tableAlias]);
+            stmt = this._container.resolve(JoinStatement, [this, this._model, table, method, AliasOrForeignKey, fkOrPkKey, null, this._tableAlias]);
         }
         else if (arguments.length === 5) {
-            stmt = this._container.resolve(statements_1.JoinStatement, [this, this._model, table, method, fkOrPkKey, primaryKey, AliasOrForeignKey, this._tableAlias]);
+            stmt = this._container.resolve(JoinStatement, [this, this._model, table, method, fkOrPkKey, primaryKey, AliasOrForeignKey, this._tableAlias]);
         }
         else {
-            stmt = this._container.resolve(statements_1.JoinStatement, [this, this._model, table, method]);
+            stmt = this._container.resolve(JoinStatement, [this, this._model, table, method]);
         }
         this.JoinStatements.push(stmt);
     }
 }
-exports.JoinBuilder = JoinBuilder;
 let WithRecursiveBuilder = class WithRecursiveBuilder {
     get CteRecursive() {
         return this._cteStatement;
     }
     withRecursive(rcKeyName, pkName) {
-        this._cteStatement = this._container.resolve(statements_1.WithRecursiveStatement, ['cte', this, rcKeyName, pkName]);
+        this._cteStatement = this._container.resolve(WithRecursiveStatement, ['cte', this, rcKeyName, pkName]);
         return this;
     }
 };
 WithRecursiveBuilder = __decorate([
-    (0, di_1.NewInstance)()
+    NewInstance()
 ], WithRecursiveBuilder);
-exports.WithRecursiveBuilder = WithRecursiveBuilder;
+export { WithRecursiveBuilder };
 let WhereBuilder = WhereBuilder_1 = class WhereBuilder {
-    constructor(container, tableAlias) {
-        this._statements = [];
-        this._boolean = enums_1.WhereBoolean.AND;
-        this._container = container;
-        this._boolean = enums_1.WhereBoolean.AND;
-        this._statements = [];
-        this._tableAlias = tableAlias;
-    }
     get Statements() {
         return this._statements;
     }
     get Op() {
         return this._boolean;
     }
+    constructor(container, tableAlias) {
+        this._statements = [];
+        this._boolean = WhereBoolean.AND;
+        this._container = container;
+        this._boolean = WhereBoolean.AND;
+        this._statements = [];
+        this._tableAlias = tableAlias;
+    }
     where(column, operator, value) {
         const self = this;
         // Support "where true || where false"
@@ -505,18 +477,18 @@ let WhereBuilder = WhereBuilder_1 = class WhereBuilder {
             return this.where(RawQuery.create(column ? 'TRUE' : 'FALSE'));
         }
         if (column instanceof RawQuery) {
-            this.Statements.push(this._container.resolve(statements_1.RawQueryStatement, [column.Query, column.Bindings, self._tableAlias]));
+            this.Statements.push(this._container.resolve(RawQueryStatement, [column.Query, column.Bindings, self._tableAlias]));
             return this;
         }
         // handle nested where's
         if (_.isFunction(column)) {
             const builder = new WhereBuilder_1(this._container, this._tableAlias);
             column.call(builder);
-            self.Statements.push(this._container.resolve(statements_1.WhereQueryStatement, [builder, self._tableAlias]));
+            self.Statements.push(this._container.resolve(WhereQueryStatement, [builder, self._tableAlias]));
             return this;
         }
         // handle simple key = object[key] AND ....
-        if (_.isObject(column) && !(column instanceof statements_1.Wrap)) {
+        if (_.isObject(column) && !(column instanceof Wrap)) {
             return this.whereObject(column);
         }
         if (typeof value === 'undefined') {
@@ -530,15 +502,15 @@ let WhereBuilder = WhereBuilder_1 = class WhereBuilder {
         function _handleForTwo(c, v) {
             let sVal = v;
             if (sVal === undefined) {
-                throw new exceptions_1.InvalidArgument(`value cannot be undefined`);
+                throw new InvalidArgument(`value cannot be undefined`);
             }
-            if (!_.isString(c) && !(c instanceof statements_1.Wrap)) {
-                throw new exceptions_1.InvalidArgument(`column is not of type string or wrapped.`);
+            if (!_.isString(c) && !(c instanceof Wrap)) {
+                throw new InvalidArgument(`column is not of type string or wrapped.`);
             }
             if (sVal === null) {
                 return this.whereNull(c);
             }
-            self._statements.push(self._container.resolve(statements_1.WhereStatement, [c, enums_1.SqlOperator.EQ, sVal, self._tableAlias, this._container, self._model]));
+            self._statements.push(self._container.resolve(WhereStatement, [c, SqlOperator.EQ, sVal, self._tableAlias, this._container, self._model]));
             return self;
         }
         /**
@@ -548,76 +520,76 @@ let WhereBuilder = WhereBuilder_1 = class WhereBuilder {
         function _handleForThree(c, o, v) {
             let sVal = v;
             if (!isWhereOperator(o)) {
-                throw new exceptions_1.InvalidArgument(`operator ${o} is invalid`);
+                throw new InvalidArgument(`operator ${o} is invalid`);
             }
-            if (!_.isString(c) && !(c instanceof statements_1.Wrap)) {
-                throw new exceptions_1.InvalidArgument(`column is not of type string or wrapped.`);
+            if (!_.isString(c) && !(c instanceof Wrap)) {
+                throw new InvalidArgument(`column is not of type string or wrapped.`);
             }
             if (sVal === null) {
                 return this.whereNull(c);
             }
             if (sVal === null) {
-                return o === enums_1.SqlOperator.NOT_NULL ? this.whereNotNull(c) : this.whereNull(c);
+                return o === SqlOperator.NOT_NULL ? this.whereNotNull(c) : this.whereNull(c);
             }
-            self._statements.push(self._container.resolve(statements_1.WhereStatement, [c, o, sVal, self._tableAlias, this._container, self._model]));
+            self._statements.push(self._container.resolve(WhereStatement, [c, o, sVal, self._tableAlias, this._container, self._model]));
             return this;
         }
     }
     orWhere(column, ..._args) {
-        this._boolean = enums_1.WhereBoolean.OR;
+        this._boolean = WhereBoolean.OR;
         return this.where(column, ...Array.from(arguments).slice(1));
     }
     andWhere(column, ..._args) {
-        this._boolean = enums_1.WhereBoolean.AND;
+        this._boolean = WhereBoolean.AND;
         return this.where(column, ...Array.from(arguments).slice(1));
     }
     whereObject(obj) {
         for (const key of Object.keys(obj)) {
-            this.andWhere(key, enums_1.SqlOperator.EQ, obj[key]);
+            this.andWhere(key, SqlOperator.EQ, obj[key]);
         }
         return this;
     }
     whereNotNull(column) {
-        this._statements.push(this._container.resolve(statements_1.WhereStatement, [column, enums_1.SqlOperator.NOT_NULL, null, this._tableAlias, this._container]));
+        this._statements.push(this._container.resolve(WhereStatement, [column, SqlOperator.NOT_NULL, null, this._tableAlias, this._container]));
         return this;
     }
     whereNull(column) {
-        this._statements.push(this._container.resolve(statements_1.WhereStatement, [column, enums_1.SqlOperator.NULL, null, this._tableAlias, this._container]));
+        this._statements.push(this._container.resolve(WhereStatement, [column, SqlOperator.NULL, null, this._tableAlias, this._container]));
         return this;
     }
     whereNot(column, val) {
-        return this.where(column, enums_1.SqlOperator.NOT, val);
+        return this.where(column, SqlOperator.NOT, val);
     }
     whereIn(column, val) {
-        this._statements.push(this._container.resolve(statements_1.InStatement, [column, val, false, this._tableAlias, this._container]));
+        this._statements.push(this._container.resolve(InStatement, [column, val, false, this._tableAlias, this._container]));
         return this;
     }
     whereNotIn(column, val) {
-        this._statements.push(this._container.resolve(statements_1.InStatement, [column, val, true, this._tableAlias, this._container]));
+        this._statements.push(this._container.resolve(InStatement, [column, val, true, this._tableAlias, this._container]));
         return this;
     }
     whereExist(query) {
-        this._statements.push(this._container.resolve(statements_1.ExistsQueryStatement, [query, false]));
+        this._statements.push(this._container.resolve(ExistsQueryStatement, [query, false]));
         return this;
     }
     whereNotExists(query) {
-        this._statements.push(this._container.resolve(statements_1.ExistsQueryStatement, [query, true]));
+        this._statements.push(this._container.resolve(ExistsQueryStatement, [query, true]));
         return this;
     }
     whereBetween(column, val) {
-        this._statements.push(this._container.resolve(statements_1.BetweenStatement, [column, val, false, this._tableAlias]));
+        this._statements.push(this._container.resolve(BetweenStatement, [column, val, false, this._tableAlias]));
         return this;
     }
     whereNotBetween(column, val) {
-        this._statements.push(this._container.resolve(statements_1.BetweenStatement, [column, val, true, this._tableAlias]));
+        this._statements.push(this._container.resolve(BetweenStatement, [column, val, true, this._tableAlias]));
         return this;
     }
     whereInSet(column, val) {
-        this._statements.push(this._container.resolve(statements_1.InSetStatement, [column, val, false, this._tableAlias]));
+        this._statements.push(this._container.resolve(InSetStatement, [column, val, false, this._tableAlias]));
         return this;
     }
     whereNotInSet(column, val) {
-        this._statements.push(this._container.resolve(statements_1.InSetStatement, [column, val, true, this._tableAlias]));
+        this._statements.push(this._container.resolve(InSetStatement, [column, val, true, this._tableAlias]));
         return this;
     }
     clearWhere() {
@@ -626,11 +598,20 @@ let WhereBuilder = WhereBuilder_1 = class WhereBuilder {
     }
 };
 WhereBuilder = WhereBuilder_1 = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [di_1.Container, String])
+    NewInstance(),
+    __metadata("design:paramtypes", [Container, String])
 ], WhereBuilder);
-exports.WhereBuilder = WhereBuilder;
-class SelectQueryBuilder extends QueryBuilder {
+export { WhereBuilder };
+let SelectQueryBuilder = SelectQueryBuilder_1 = class SelectQueryBuilder extends QueryBuilder {
+    get Owner() {
+        return this._owner;
+    }
+    get IsDistinct() {
+        return this._distinct;
+    }
+    get Relations() {
+        return this._relations;
+    }
     constructor(container, driver, model, owner) {
         super(container, driver, model);
         this._columns = [];
@@ -643,11 +624,11 @@ class SelectQueryBuilder extends QueryBuilder {
         this._relations = [];
         this._owner = owner;
         this._distinct = false;
-        this._method = enums_1.QueryMethod.SELECT;
-        this._boolean = enums_1.WhereBoolean.AND;
+        this._method = QueryMethod.SELECT;
+        this._boolean = WhereBoolean.AND;
         this._sort = {
             column: '',
-            order: enums_1.SordOrder.ASC,
+            order: SordOrder.ASC,
         };
         this._first = false;
         this._limit = {
@@ -655,18 +636,9 @@ class SelectQueryBuilder extends QueryBuilder {
             offset: -1,
         };
         this._nonSelect = false;
-        this.QueryContext = interfaces_1.QueryContext.Select;
+        this.QueryContext = QueryContext.Select;
         this._queryMiddlewares.forEach((x) => x.afterQueryCreation(this));
     }
-    get Owner() {
-        return this._owner;
-    }
-    get IsDistinct() {
-        return this._distinct;
-    }
-    get Relations() {
-        return this._relations;
-    }
     async asRaw() {
         this._asRaw = true;
         return (await this);
@@ -679,12 +651,12 @@ class SelectQueryBuilder extends QueryBuilder {
         return this;
     }
     clone() {
-        const builder = new SelectQueryBuilder(this._container, this._driver, this._model, this._owner);
+        const builder = new SelectQueryBuilder_1(this._container, this._driver, this._model, this._owner);
         builder._columns = this._columns.slice(0);
         builder._joinStatements = this._joinStatements.slice(0);
         builder._statements = this._statements.slice(0);
-        builder._limit = Object.assign({}, this._limit);
-        builder._sort = Object.assign({}, this._sort);
+        builder._limit = { ...this._limit };
+        builder._sort = { ...this._sort };
         builder._boolean = this._boolean;
         builder._distinct = this._distinct;
         builder._table = this._table;
@@ -692,7 +664,6 @@ class SelectQueryBuilder extends QueryBuilder {
         return builder;
     }
     populate(relation, callback) {
-        var _a;
         // if relation was already populated, just call callback on it
         const fRelation = this._relations.find((r) => r.Name === relation);
         if (fRelation) {
@@ -700,27 +671,27 @@ class SelectQueryBuilder extends QueryBuilder {
             return;
         }
         let relInstance = null;
-        const descriptor = (0, model_1.extractModelDescriptor)(this._model);
+        const descriptor = extractModelDescriptor(this._model);
         if (!descriptor.Relations.has(relation)) {
-            throw new exceptions_1.InvalidArgument(`Relation ${relation} not exists in model ${(_a = this._model) === null || _a === void 0 ? void 0 : _a.constructor.name}`);
+            throw new InvalidArgument(`Relation ${relation} not exists in model ${this._model?.constructor.name}`);
         }
         const relDescription = descriptor.Relations.get(relation);
-        if (relDescription.Type === interfaces_1.RelationType.One && relDescription.Recursive) {
-            relInstance = this._container.resolve(relations_1.BelongsToRecursiveRelation, [this._container.get(orm_1.Orm), this, relDescription, this._owner]);
+        if (relDescription.Type === RelationType.One && relDescription.Recursive) {
+            relInstance = this._container.resolve(BelongsToRecursiveRelation, [this._container.get(Orm), this, relDescription, this._owner]);
         }
         else {
             if (relDescription.Recursive) {
-                throw new exceptions_1.InvalidOperation(`cannot mark relation as recursive with non one-to-one relation type`);
+                throw new InvalidOperation(`cannot mark relation as recursive with non one-to-one relation type`);
             }
             switch (relDescription.Type) {
-                case interfaces_1.RelationType.One:
-                    relInstance = this._container.resolve(relations_1.BelongsToRelation, [this._container.get(orm_1.Orm), this, relDescription, this._owner]);
+                case RelationType.One:
+                    relInstance = this._container.resolve(BelongsToRelation, [this._container.get(Orm), this, relDescription, this._owner]);
                     break;
-                case interfaces_1.RelationType.Many:
-                    relInstance = this._container.resolve(relations_1.OneToManyRelation, [this._container.get(orm_1.Orm), this, relDescription, this._owner]);
+                case RelationType.Many:
+                    relInstance = this._container.resolve(OneToManyRelation, [this._container.get(Orm), this, relDescription, this._owner]);
                     break;
-                case interfaces_1.RelationType.ManyToMany:
-                    relInstance = this._container.resolve(relations_1.ManyToManyRelation, [this._container.get(orm_1.Orm), this, relDescription, null]);
+                case RelationType.ManyToMany:
+                    relInstance = this._container.resolve(ManyToManyRelation, [this._container.get(Orm), this, relDescription, null]);
                     break;
             }
         }
@@ -737,34 +708,34 @@ class SelectQueryBuilder extends QueryBuilder {
         this._middlewares = this._middlewares.concat(builder._middlewares);
     }
     min(column, as) {
-        this._columns.push(this._container.resolve(statements_1.ColumnMethodStatement, [column, enums_1.ColumnMethods.MIN, as, this._tableAlias]));
+        this._columns.push(this._container.resolve(ColumnMethodStatement, [column, ColumnMethods.MIN, as, this._tableAlias]));
         return this;
     }
     max(column, as) {
-        this._columns.push(this._container.resolve(statements_1.ColumnMethodStatement, [column, enums_1.ColumnMethods.MAX, as, this._tableAlias]));
+        this._columns.push(this._container.resolve(ColumnMethodStatement, [column, ColumnMethods.MAX, as, this._tableAlias]));
         return this;
     }
     count(column, as) {
-        this._columns.push(this._container.resolve(statements_1.ColumnMethodStatement, [column, enums_1.ColumnMethods.COUNT, as, this._tableAlias]));
+        this._columns.push(this._container.resolve(ColumnMethodStatement, [column, ColumnMethods.COUNT, as, this._tableAlias]));
         return this;
     }
     sum(column, as) {
-        this._columns.push(this._container.resolve(statements_1.ColumnMethodStatement, [column, enums_1.ColumnMethods.SUM, as, this._tableAlias]));
+        this._columns.push(this._container.resolve(ColumnMethodStatement, [column, ColumnMethods.SUM, as, this._tableAlias]));
         return this;
     }
     avg(column, as) {
-        this._columns.push(this._container.resolve(statements_1.ColumnMethodStatement, [column, enums_1.ColumnMethods.AVG, as, this._tableAlias]));
+        this._columns.push(this._container.resolve(ColumnMethodStatement, [column, ColumnMethods.AVG, as, this._tableAlias]));
         return this;
     }
     distinct() {
         if (this._columns.length === 0 || this._columns[0].IsWildcard) {
-            throw new exceptions_1.InvalidOperation('Cannot force DISTINCT on unknown column');
+            throw new InvalidOperation('Cannot force DISTINCT on unknown column');
         }
         this._distinct = true;
         return this;
     }
     toDB() {
-        const compiler = this._container.resolve(interfaces_1.SelectQueryCompiler, [this]);
+        const compiler = this._container.resolve(SelectQueryCompiler, [this]);
         return compiler.compile();
     }
     then(onfulfilled, onrejected) {
@@ -790,37 +761,41 @@ class SelectQueryBuilder extends QueryBuilder {
     async execute() {
         return (await this);
     }
-}
+};
 __decorate([
-    (0, typescript_mix_1.use)(WhereBuilder, LimitBuilder, OrderByBuilder, ColumnsBuilder, JoinBuilder, WithRecursiveBuilder, GroupByBuilder),
+    use(WhereBuilder, LimitBuilder, OrderByBuilder, ColumnsBuilder, JoinBuilder, WithRecursiveBuilder, GroupByBuilder),
     __metadata("design:type", Object)
 ], SelectQueryBuilder.prototype, "this", void 0);
-exports.SelectQueryBuilder = SelectQueryBuilder;
-class SelectQueryBuilderC extends SelectQueryBuilder {
+SelectQueryBuilder = SelectQueryBuilder_1 = __decorate([
+    Injectable(SelectQueryBuilder_1),
+    __metadata("design:paramtypes", [Object, OrmDriver, Object, Object])
+], SelectQueryBuilder);
+export { SelectQueryBuilder };
+export class SelectQueryBuilderC extends SelectQueryBuilder {
 }
-exports.SelectQueryBuilderC = SelectQueryBuilderC;
-class DeleteQueryBuilder extends QueryBuilder {
+export class DeleteQueryBuilder extends QueryBuilder {
     constructor(container, driver, model) {
         super(container, driver, model);
-        this._method = enums_1.QueryMethod.DELETE;
+        this._method = QueryMethod.DELETE;
         this._statements = [];
-        this._boolean = enums_1.WhereBoolean.AND;
+        this._boolean = WhereBoolean.AND;
         this._limit = {
             limit: -1,
             offset: -1,
         };
-        this.QueryContext = interfaces_1.QueryContext.Delete;
+        this.QueryContext = QueryContext.Delete;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.DeleteQueryCompiler, [this]).compile();
+        return this._container.resolve(DeleteQueryCompiler, [this]).compile();
     }
 }
 __decorate([
-    (0, typescript_mix_1.use)(WhereBuilder, LimitBuilder),
+    use(WhereBuilder, LimitBuilder)
+    /// @ts-ignore
+    ,
     __metadata("design:type", Object)
 ], DeleteQueryBuilder.prototype, "this", void 0);
-exports.DeleteQueryBuilder = DeleteQueryBuilder;
-class OnDuplicateQueryBuilder {
+export class OnDuplicateQueryBuilder {
     constructor(container, insertQueryBuilder, column) {
         this._parent = insertQueryBuilder;
         this._container = container;
@@ -846,18 +821,17 @@ class OnDuplicateQueryBuilder {
         return this._parent.toDB();
     }
 }
-exports.OnDuplicateQueryBuilder = OnDuplicateQueryBuilder;
-class UpdateQueryBuilder extends QueryBuilder {
+export class UpdateQueryBuilder extends QueryBuilder {
+    get Value() {
+        return this._value;
+    }
     constructor(container, driver, model) {
         super(container, driver, model);
         this._value = {};
-        this._method = enums_1.QueryMethod.UPDATE;
-        this._boolean = enums_1.WhereBoolean.AND;
+        this._method = QueryMethod.UPDATE;
+        this._boolean = WhereBoolean.AND;
         this._statements = [];
-        this.QueryContext = interfaces_1.QueryContext.Update;
-    }
-    get Value() {
-        return this._value;
+        this.QueryContext = QueryContext.Update;
     }
     in(name) {
         this.setTable(name);
@@ -868,22 +842,14 @@ class UpdateQueryBuilder extends QueryBuilder {
         return this;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.UpdateQueryCompiler, [this]).compile();
+        return this._container.resolve(UpdateQueryCompiler, [this]).compile();
     }
 }
 __decorate([
-    (0, typescript_mix_1.use)(WhereBuilder),
+    use(WhereBuilder),
     __metadata("design:type", Object)
 ], UpdateQueryBuilder.prototype, "this", void 0);
-exports.UpdateQueryBuilder = UpdateQueryBuilder;
-class InsertQueryBuilder extends QueryBuilder {
-    constructor(container, driver, model) {
-        super(container, driver, model);
-        this._method = enums_1.QueryMethod.INSERT;
-        this._columns = [];
-        this._values = [];
-        this.QueryContext = interfaces_1.QueryContext.Insert;
-    }
+export class InsertQueryBuilder extends QueryBuilder {
     get Values() {
         return this._values;
     }
@@ -896,6 +862,13 @@ class InsertQueryBuilder extends QueryBuilder {
     get Replace() {
         return this._replace;
     }
+    constructor(container, driver, model) {
+        super(container, driver, model);
+        this._method = QueryMethod.INSERT;
+        this._columns = [];
+        this._values = [];
+        this.QueryContext = QueryContext.Insert;
+    }
     /**
      * Sets insert to ignore on duplicate
      */
@@ -940,7 +913,7 @@ class InsertQueryBuilder extends QueryBuilder {
     onDuplicate(column) {
         let columnToCheck = column;
         if (!columnToCheck && this._model) {
-            const dsc = (0, model_1.extractModelDescriptor)(this._model);
+            const dsc = extractModelDescriptor(this._model);
             columnToCheck = dsc.Columns.filter((c) => c.Unique).map((c) => c.Name);
         }
         this._update = true;
@@ -948,18 +921,17 @@ class InsertQueryBuilder extends QueryBuilder {
         return this.DuplicateQueryBuilder;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.InsertQueryCompiler, [this]).compile();
+        return this._container.resolve(InsertQueryCompiler, [this]).compile();
     }
 }
 __decorate([
-    (0, typescript_mix_1.use)(ColumnsBuilder),
+    use(ColumnsBuilder),
     __metadata("design:type", Object)
 ], InsertQueryBuilder.prototype, "this", void 0);
-exports.InsertQueryBuilder = InsertQueryBuilder;
 let IndexQueryBuilder = class IndexQueryBuilder extends Builder {
     constructor(container, driver) {
         super(container, driver);
-        this.QueryContext = interfaces_1.QueryContext.Schema;
+        this.QueryContext = QueryContext.Schema;
     }
     name(name) {
         this.Name = name;
@@ -978,19 +950,19 @@ let IndexQueryBuilder = class IndexQueryBuilder extends Builder {
         return this;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.IndexQueryCompiler, [this]).compile();
+        return this._container.resolve(IndexQueryCompiler, [this]).compile();
     }
 };
 IndexQueryBuilder = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, driver_1.OrmDriver])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, OrmDriver])
 ], IndexQueryBuilder);
-exports.IndexQueryBuilder = IndexQueryBuilder;
+export { IndexQueryBuilder };
 let ForeignKeyBuilder = class ForeignKeyBuilder {
     constructor() {
-        this.OnDeleteAction = interfaces_1.ReferentialAction.NoAction;
-        this.OnUpdateAction = interfaces_1.ReferentialAction.NoAction;
+        this.OnDeleteAction = ReferentialAction.NoAction;
+        this.OnUpdateAction = ReferentialAction.NoAction;
     }
     /**
      *
@@ -1038,16 +1010,16 @@ let ForeignKeyBuilder = class ForeignKeyBuilder {
      * Shorhand for on update and on delete cascade settings
      */
     cascade() {
-        this.OnUpdateAction = interfaces_1.ReferentialAction.Cascade;
-        this.OnDeleteAction = interfaces_1.ReferentialAction.Cascade;
+        this.OnUpdateAction = ReferentialAction.Cascade;
+        this.OnDeleteAction = ReferentialAction.Cascade;
         return this;
     }
 };
 ForeignKeyBuilder = __decorate([
-    (0, di_1.NewInstance)(),
+    NewInstance(),
     __metadata("design:paramtypes", [])
 ], ForeignKeyBuilder);
-exports.ForeignKeyBuilder = ForeignKeyBuilder;
+export { ForeignKeyBuilder };
 let ColumnQueryBuilder = class ColumnQueryBuilder {
     constructor(container, name, type, ...args) {
         this.container = container;
@@ -1080,7 +1052,7 @@ let ColumnQueryBuilder = class ColumnQueryBuilder {
         return this;
     }
     default() {
-        this.Default = this.container.resolve((interfaces_1.DefaultValueBuilder), [this]);
+        this.Default = this.container.resolve((DefaultValueBuilder), [this]);
         return this.Default;
     }
     primaryKey() {
@@ -1101,28 +1073,28 @@ let ColumnQueryBuilder = class ColumnQueryBuilder {
     }
 };
 ColumnQueryBuilder = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
+    NewInstance(),
+    Inject(Container),
     __metadata("design:paramtypes", [Object, String, String, Object])
 ], ColumnQueryBuilder);
-exports.ColumnQueryBuilder = ColumnQueryBuilder;
+export { ColumnQueryBuilder };
 let AlterColumnQueryBuilder = class AlterColumnQueryBuilder extends ColumnQueryBuilder {
     constructor(container, name, type, ...args) {
         super(container, name, type, ...args);
         this.OldName = name;
         // we assume add by default
-        this.AlterType = interfaces_1.ColumnAlterationType.Add;
+        this.AlterType = ColumnAlterationType.Add;
     }
     addColumn() {
-        this.AlterType = interfaces_1.ColumnAlterationType.Add;
+        this.AlterType = ColumnAlterationType.Add;
         return this;
     }
     modify() {
-        this.AlterType = interfaces_1.ColumnAlterationType.Modify;
+        this.AlterType = ColumnAlterationType.Modify;
         return this;
     }
     rename(newName) {
-        this.AlterType = interfaces_1.ColumnAlterationType.Rename;
+        this.AlterType = ColumnAlterationType.Rename;
         this.Name = newName;
         return this;
     }
@@ -1132,22 +1104,21 @@ let AlterColumnQueryBuilder = class AlterColumnQueryBuilder extends ColumnQueryB
     }
 };
 AlterColumnQueryBuilder = __decorate([
-    (0, di_1.Inject)(di_1.Container),
+    Inject(Container),
     __metadata("design:paramtypes", [Object, String, String, Object])
 ], AlterColumnQueryBuilder);
-exports.AlterColumnQueryBuilder = AlterColumnQueryBuilder;
-class TableExistsQueryBuilder extends QueryBuilder {
+export { AlterColumnQueryBuilder };
+export class TableExistsQueryBuilder extends QueryBuilder {
     constructor(container, driver, name) {
         super(container, driver, null);
         this.setTable(name);
-        this.QueryContext = interfaces_1.QueryContext.Select;
+        this.QueryContext = QueryContext.Select;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.TableExistsCompiler, [this]).compile();
+        return this._container.resolve(TableExistsCompiler, [this]).compile();
     }
 }
-exports.TableExistsQueryBuilder = TableExistsQueryBuilder;
-class DropTableQueryBuilder extends QueryBuilder {
+export class DropTableQueryBuilder extends QueryBuilder {
     constructor(container, driver, name, database) {
         super(container, driver, null);
         this.setTable(name);
@@ -1155,28 +1126,27 @@ class DropTableQueryBuilder extends QueryBuilder {
             this.database(database);
         }
         this.Exists = false;
-        this.QueryContext = interfaces_1.QueryContext.Schema;
+        this.QueryContext = QueryContext.Schema;
     }
     ifExists() {
         this.Exists = true;
         return this;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.DropTableCompiler, [this]).compile();
+        return this._container.resolve(DropTableCompiler, [this]).compile();
     }
 }
-exports.DropTableQueryBuilder = DropTableQueryBuilder;
-class AlterTableQueryBuilder extends QueryBuilder {
+export class AlterTableQueryBuilder extends QueryBuilder {
+    get Columns() {
+        return this._columns;
+    }
     constructor(container, driver, name) {
         super(container, driver, null);
         this.setTable(name);
-        this.QueryContext = interfaces_1.QueryContext.Schema;
+        this.QueryContext = QueryContext.Schema;
         this._columns = [];
         this.DroppedColumns = [];
     }
-    get Columns() {
-        return this._columns;
-    }
     /**
      * Renames table
      *
@@ -1189,22 +1159,10 @@ class AlterTableQueryBuilder extends QueryBuilder {
         this.DroppedColumns.push(column);
     }
     toDB() {
-        return this._container.resolve(interfaces_1.AlterTableQueryCompiler, [this]).compile();
+        return this._container.resolve(AlterTableQueryCompiler, [this]).compile();
     }
 }
-exports.AlterTableQueryBuilder = AlterTableQueryBuilder;
-class TableQueryBuilder extends QueryBuilder {
-    constructor(container, driver, name) {
-        super(container, driver, null);
-        this._charset = '';
-        this._comment = '';
-        this._columns = [];
-        this._foreignKeys = [];
-        this._temporary = false;
-        this._trackHistory = false;
-        this.setTable(name);
-        this.QueryContext = interfaces_1.QueryContext.Schema;
-    }
+export class TableQueryBuilder extends QueryBuilder {
     /**
      * Alias for string(name, 36 )
      */
@@ -1245,6 +1203,17 @@ class TableQueryBuilder extends QueryBuilder {
     get TrackHistory() {
         return this._trackHistory;
     }
+    constructor(container, driver, name) {
+        super(container, driver, null);
+        this._charset = '';
+        this._comment = '';
+        this._columns = [];
+        this._foreignKeys = [];
+        this._temporary = false;
+        this._trackHistory = false;
+        this.setTable(name);
+        this.QueryContext = QueryContext.Schema;
+    }
     increments(name) {
         return this.int(name).autoIncrement().notNull().primaryKey();
     }
@@ -1261,10 +1230,9 @@ class TableQueryBuilder extends QueryBuilder {
         return builder;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.TableQueryCompiler, [this]).compile();
+        return this._container.resolve(TableQueryCompiler, [this]).compile();
     }
 }
-exports.TableQueryBuilder = TableQueryBuilder;
 let TruncateTableQueryBuilder = class TruncateTableQueryBuilder extends QueryBuilder {
     constructor(container, driver) {
         super(container, driver);
@@ -1272,24 +1240,16 @@ let TruncateTableQueryBuilder = class TruncateTableQueryBuilder extends QueryBui
         this.driver = driver;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.TruncateTableQueryCompiler, [this]).compile();
+        return this._container.resolve(TruncateTableQueryCompiler, [this]).compile();
     }
 };
 TruncateTableQueryBuilder = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, driver_1.OrmDriver])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, OrmDriver])
 ], TruncateTableQueryBuilder);
-exports.TruncateTableQueryBuilder = TruncateTableQueryBuilder;
+export { TruncateTableQueryBuilder };
 let CloneTableQueryBuilder = class CloneTableQueryBuilder extends QueryBuilder {
-    constructor(container, driver) {
-        super(container, driver);
-        this.container = container;
-        this.driver = driver;
-        this._shallow = true;
-        this._cloneSrc = '';
-        this._temporary = false;
-    }
     get CloneSource() {
         return this._cloneSrc;
     }
@@ -1302,6 +1262,14 @@ let CloneTableQueryBuilder = class CloneTableQueryBuilder extends QueryBuilder {
     get Filter() {
         return this._filter;
     }
+    constructor(container, driver) {
+        super(container, driver);
+        this.container = container;
+        this.driver = driver;
+        this._shallow = true;
+        this._cloneSrc = '';
+        this._temporary = false;
+    }
     /**
      * Clones table structure without data
      * Shorthand for createTable(( table) => table.clone("new"));
@@ -1333,18 +1301,17 @@ let CloneTableQueryBuilder = class CloneTableQueryBuilder extends QueryBuilder {
         return this;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.TableCloneQueryCompiler, [this]).compile();
+        return this._container.resolve(TableCloneQueryCompiler, [this]).compile();
     }
 };
 CloneTableQueryBuilder = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, driver_1.OrmDriver])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, OrmDriver])
 ], CloneTableQueryBuilder);
-exports.CloneTableQueryBuilder = CloneTableQueryBuilder;
-class EventIntervalDesc {
+export { CloneTableQueryBuilder };
+export class EventIntervalDesc {
 }
-exports.EventIntervalDesc = EventIntervalDesc;
 let EventQueryBuilder = class EventQueryBuilder extends QueryBuilder {
     constructor(container, driver, Name) {
         super(container, driver);
@@ -1380,7 +1347,7 @@ let EventQueryBuilder = class EventQueryBuilder extends QueryBuilder {
      * @param sql - code to execute,  could be raw sql query, single builder, or multiple builders that will be executed on by one
      */
     do(sql) {
-        if (sql instanceof statements_1.RawQueryStatement) {
+        if (sql instanceof RawQueryStatement) {
             this.RawSql = sql;
         }
         else if (Array.isArray(sql)) {
@@ -1400,15 +1367,15 @@ let EventQueryBuilder = class EventQueryBuilder extends QueryBuilder {
         this.Comment = comment;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.EventQueryCompiler, [this]).compile();
+        return this._container.resolve(EventQueryCompiler, [this]).compile();
     }
 };
 EventQueryBuilder = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, driver_1.OrmDriver, String])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, OrmDriver, String])
 ], EventQueryBuilder);
-exports.EventQueryBuilder = EventQueryBuilder;
+export { EventQueryBuilder };
 let DropEventQueryBuilder = class DropEventQueryBuilder extends QueryBuilder {
     constructor(container, driver, Name) {
         super(container, driver);
@@ -1417,15 +1384,15 @@ let DropEventQueryBuilder = class DropEventQueryBuilder extends QueryBuilder {
         this.Name = Name;
     }
     toDB() {
-        return this._container.resolve(interfaces_1.DropEventQueryCompiler, [this]).compile();
+        return this._container.resolve(DropEventQueryCompiler, [this]).compile();
     }
 };
 DropEventQueryBuilder = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, driver_1.OrmDriver, String])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, OrmDriver, String])
 ], DropEventQueryBuilder);
-exports.DropEventQueryBuilder = DropEventQueryBuilder;
+export { DropEventQueryBuilder };
 /**
  * Creates schedule job in database engine.
  * Note, some engines does not support this, so it will implemented
@@ -1446,11 +1413,11 @@ let ScheduleQueryBuilder = class ScheduleQueryBuilder {
     }
 };
 ScheduleQueryBuilder = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, driver_1.OrmDriver])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, OrmDriver])
 ], ScheduleQueryBuilder);
-exports.ScheduleQueryBuilder = ScheduleQueryBuilder;
+export { ScheduleQueryBuilder };
 let SchemaQueryBuilder = class SchemaQueryBuilder {
     constructor(container, driver) {
         this.container = container;
@@ -1490,19 +1457,19 @@ let SchemaQueryBuilder = class SchemaQueryBuilder {
     }
 };
 SchemaQueryBuilder = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, driver_1.OrmDriver])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, OrmDriver])
 ], SchemaQueryBuilder);
-exports.SchemaQueryBuilder = SchemaQueryBuilder;
-Object.values(enums_1.ColumnType).forEach((type) => {
+export { SchemaQueryBuilder };
+Object.values(ColumnType).forEach((type) => {
     TableQueryBuilder.prototype[type] = function (name, ...args) {
         const _builder = new ColumnQueryBuilder(this.Container, name, type, ...args);
         this._columns.push(_builder);
         return _builder;
     };
 });
-Object.values(enums_1.ColumnType).forEach((type) => {
+Object.values(ColumnType).forEach((type) => {
     AlterTableQueryBuilder.prototype[type] = function (name, ...args) {
         const _builder = new AlterColumnQueryBuilder(this.Container, name, type, ...args);
         this._columns.push(_builder);