@spinajs/orm-sql 2.0.46 → 2.0.49

package/lib/compilers.js

@@ -1,4 +1,3 @@
-"use strict";
 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);
@@ -8,21 +7,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SqlDropEventQueryCompiler = exports.SqlEventQueryCompiler = exports.SqlAlterColumnQueryCompiler = exports.SqlColumnQueryCompiler = exports.SqlTableQueryCompiler = exports.SqlTableHistoryQueryCompiler = exports.SqlTruncateTableQueryCompiler = exports.SqlTableCloneQueryCompiler = exports.SqlAlterTableQueryCompiler = exports.SqlDropTableQueryCompiler = exports.SqlInsertQueryCompiler = exports.SqlIndexQueryCompiler = exports.SqlOnDuplicateQueryCompiler = exports.SqlDeleteQueryCompiler = exports.SqlUpdateQueryCompiler = exports.SqlSelectQueryCompiler = exports.SqlJoinCompiler = exports.SqlWhereCompiler = exports.SqlColumnsCompiler = exports.SqlGroupByCompiler = exports.SqlLimitQueryCompiler = exports.SqlForeignKeyQueryCompiler = exports.SqlWithRecursiveCompiler = exports.SqlOrderByQueryCompiler = exports.SqlQueryCompiler = exports.SqlTableAliasCompiler = void 0;
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-empty-interface */
 /* eslint-disable prettier/prettier */
-const exceptions_1 = require("@spinajs/exceptions");
-const orm_1 = require("@spinajs/orm");
-const typescript_mix_1 = require("typescript-mix");
-const di_1 = require("@spinajs/di");
-const lodash_1 = __importDefault(require("lodash"));
-class SqlTableAliasCompiler {
+import { InvalidOperation, InvalidArgument } from '../../exceptions/lib/index.js';
+import { LimitBuilder, DropTableQueryBuilder, AlterColumnQueryBuilder, TableCloneQueryCompiler, OnDuplicateQueryBuilder, DeleteQueryBuilder, LimitQueryCompiler, InsertQueryBuilder, OrderByBuilder, SelectQueryBuilder, UpdateQueryBuilder, SelectQueryCompiler, TableQueryCompiler, TableQueryBuilder, ColumnQueryBuilder, ColumnQueryCompiler, RawQuery, OrderByQueryCompiler, OnDuplicateQueryCompiler, IndexQueryCompiler, IndexQueryBuilder, ForeignKeyBuilder, ForeignKeyQueryCompiler, AlterTableQueryBuilder, CloneTableQueryBuilder, AlterTableQueryCompiler, ColumnAlterationType, AlterColumnQueryCompiler, TableAliasCompiler, DropTableCompiler, DropEventQueryBuilder, TableHistoryQueryCompiler, EventQueryBuilder } from '@spinajs/orm';
+import { use } from 'typescript-mix';
+import { NewInstance, Inject, Container } from '@spinajs/di';
+import _ from 'lodash';
+export class SqlTableAliasCompiler {
     compile(builder, tbl) {
         let table = '';
         if (builder.Database) {
@@ -35,14 +29,13 @@ class SqlTableAliasCompiler {
         return table;
     }
 }
-exports.SqlTableAliasCompiler = SqlTableAliasCompiler;
-let SqlQueryCompiler = class SqlQueryCompiler extends orm_1.SelectQueryCompiler {
+let SqlQueryCompiler = class SqlQueryCompiler extends SelectQueryCompiler {
     constructor(_builder, _container) {
         super();
         this._builder = _builder;
         this._container = _container;
         if (_builder === null && _builder === undefined) {
-            throw new exceptions_1.InvalidArgument('builder cannot be null or undefined');
+            throw new InvalidArgument('builder cannot be null or undefined');
         }
     }
     tryConvertValue(v) {
@@ -56,15 +49,15 @@ let SqlQueryCompiler = class SqlQueryCompiler extends orm_1.SelectQueryCompiler
     }
 };
 SqlQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
+    NewInstance(),
     __metadata("design:paramtypes", [Object, Object])
 ], SqlQueryCompiler);
-exports.SqlQueryCompiler = SqlQueryCompiler;
-let SqlOrderByQueryCompiler = class SqlOrderByQueryCompiler extends orm_1.OrderByQueryCompiler {
+export { SqlQueryCompiler };
+let SqlOrderByQueryCompiler = class SqlOrderByQueryCompiler extends OrderByQueryCompiler {
     constructor(builder) {
         super();
         if (!builder) {
-            throw new exceptions_1.InvalidOperation('builder cannot be null or undefined');
+            throw new InvalidOperation('builder cannot be null or undefined');
         }
         this._builder = builder;
     }
@@ -83,10 +76,10 @@ let SqlOrderByQueryCompiler = class SqlOrderByQueryCompiler extends orm_1.OrderB
     }
 };
 SqlOrderByQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.OrderByBuilder])
+    NewInstance(),
+    __metadata("design:paramtypes", [OrderByBuilder])
 ], SqlOrderByQueryCompiler);
-exports.SqlOrderByQueryCompiler = SqlOrderByQueryCompiler;
+export { SqlOrderByQueryCompiler };
 let SqlWithRecursiveCompiler = class SqlWithRecursiveCompiler {
     recursive(builder) {
         const statement = builder.CteRecursive.build();
@@ -104,9 +97,9 @@ let SqlWithRecursiveCompiler = class SqlWithRecursiveCompiler {
     }
 };
 SqlWithRecursiveCompiler = __decorate([
-    (0, di_1.NewInstance)()
+    NewInstance()
 ], SqlWithRecursiveCompiler);
-exports.SqlWithRecursiveCompiler = SqlWithRecursiveCompiler;
+export { SqlWithRecursiveCompiler };
 let SqlForeignKeyQueryCompiler = class SqlForeignKeyQueryCompiler {
     constructor(_builder) {
         this._builder = _builder;
@@ -123,15 +116,15 @@ let SqlForeignKeyQueryCompiler = class SqlForeignKeyQueryCompiler {
     }
 };
 SqlForeignKeyQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.ForeignKeyBuilder])
+    NewInstance(),
+    __metadata("design:paramtypes", [ForeignKeyBuilder])
 ], SqlForeignKeyQueryCompiler);
-exports.SqlForeignKeyQueryCompiler = SqlForeignKeyQueryCompiler;
-let SqlLimitQueryCompiler = class SqlLimitQueryCompiler extends orm_1.LimitQueryCompiler {
+export { SqlForeignKeyQueryCompiler };
+let SqlLimitQueryCompiler = class SqlLimitQueryCompiler extends LimitQueryCompiler {
     constructor(builder) {
         super();
         if (!builder) {
-            throw new exceptions_1.InvalidOperation('builder cannot be null or undefined');
+            throw new InvalidOperation('builder cannot be null or undefined');
         }
         this._builder = builder;
     }
@@ -159,10 +152,10 @@ let SqlLimitQueryCompiler = class SqlLimitQueryCompiler extends orm_1.LimitQuery
     }
 };
 SqlLimitQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.LimitBuilder])
+    NewInstance(),
+    __metadata("design:paramtypes", [LimitBuilder])
 ], SqlLimitQueryCompiler);
-exports.SqlLimitQueryCompiler = SqlLimitQueryCompiler;
+export { SqlLimitQueryCompiler };
 let SqlGroupByCompiler = class SqlGroupByCompiler {
     group(builder) {
         let bindings = [];
@@ -177,9 +170,9 @@ let SqlGroupByCompiler = class SqlGroupByCompiler {
     }
 };
 SqlGroupByCompiler = __decorate([
-    (0, di_1.NewInstance)()
+    NewInstance()
 ], SqlGroupByCompiler);
-exports.SqlGroupByCompiler = SqlGroupByCompiler;
+export { SqlGroupByCompiler };
 let SqlColumnsCompiler = class SqlColumnsCompiler {
     columns(builder) {
         return {
@@ -194,9 +187,9 @@ let SqlColumnsCompiler = class SqlColumnsCompiler {
     }
 };
 SqlColumnsCompiler = __decorate([
-    (0, di_1.NewInstance)()
+    NewInstance()
 ], SqlColumnsCompiler);
-exports.SqlColumnsCompiler = SqlColumnsCompiler;
+export { SqlColumnsCompiler };
 let SqlWhereCompiler = class SqlWhereCompiler {
     where(builder) {
         const where = [];
@@ -216,22 +209,22 @@ let SqlWhereCompiler = class SqlWhereCompiler {
     }
 };
 SqlWhereCompiler = __decorate([
-    (0, di_1.NewInstance)()
+    NewInstance()
 ], SqlWhereCompiler);
-exports.SqlWhereCompiler = SqlWhereCompiler;
+export { SqlWhereCompiler };
 let SqlJoinCompiler = class SqlJoinCompiler {
     join(builder) {
         const result = builder.JoinStatements.map((s) => s.build());
         return {
-            bindings: lodash_1.default.flatMap(result, (r) => r.Bindings),
-            expression: lodash_1.default.flatMap(result, (r) => r.Statements).join(' '),
+            bindings: _.flatMap(result, (r) => r.Bindings),
+            expression: _.flatMap(result, (r) => r.Statements).join(' '),
         };
     }
 };
 SqlJoinCompiler = __decorate([
-    (0, di_1.NewInstance)()
+    NewInstance()
 ], SqlJoinCompiler);
-exports.SqlJoinCompiler = SqlJoinCompiler;
+export { SqlJoinCompiler };
 let SqlSelectQueryCompiler = class SqlSelectQueryCompiler extends SqlQueryCompiler {
     constructor(_container, builder) {
         super(builder, _container);
@@ -260,11 +253,11 @@ let SqlSelectQueryCompiler = class SqlSelectQueryCompiler extends SqlQueryCompil
         };
     }
     limit() {
-        const compiler = this._container.resolve(orm_1.LimitQueryCompiler, [this._builder]);
+        const compiler = this._container.resolve(LimitQueryCompiler, [this._builder]);
         return compiler.compile();
     }
     sort() {
-        const compiler = this._container.resolve(orm_1.OrderByQueryCompiler, [this._builder]);
+        const compiler = this._container.resolve(OrderByQueryCompiler, [this._builder]);
         return compiler.compile();
     }
     select() {
@@ -278,19 +271,19 @@ let SqlSelectQueryCompiler = class SqlSelectQueryCompiler extends SqlQueryCompil
         return _stmt + this.columns(this._builder).expression;
     }
     from() {
-        return 'FROM ' + this._container.resolve(orm_1.TableAliasCompiler).compile(this._builder);
+        return 'FROM ' + this._container.resolve(TableAliasCompiler).compile(this._builder);
     }
 };
 __decorate([
-    (0, typescript_mix_1.use)(SqlWhereCompiler, SqlColumnsCompiler, orm_1.TableAliasCompiler, SqlJoinCompiler, SqlWithRecursiveCompiler, SqlGroupByCompiler),
+    use(SqlWhereCompiler, SqlColumnsCompiler, TableAliasCompiler, SqlJoinCompiler, SqlWithRecursiveCompiler, SqlGroupByCompiler),
     __metadata("design:type", Object)
 ], SqlSelectQueryCompiler.prototype, "this", void 0);
 SqlSelectQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [Object, orm_1.SelectQueryBuilder])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, SelectQueryBuilder])
 ], SqlSelectQueryCompiler);
-exports.SqlSelectQueryCompiler = SqlSelectQueryCompiler;
+export { SqlSelectQueryCompiler };
 let SqlUpdateQueryCompiler = class SqlUpdateQueryCompiler extends SqlQueryCompiler {
     constructor(_container, builder) {
         super(builder, _container);
@@ -322,18 +315,18 @@ let SqlUpdateQueryCompiler = class SqlUpdateQueryCompiler extends SqlQueryCompil
         };
     }
     table() {
-        return `UPDATE ${this._container.resolve(orm_1.TableAliasCompiler).compile(this._builder)} SET`;
+        return `UPDATE ${this._container.resolve(TableAliasCompiler).compile(this._builder)} SET`;
     }
 };
 __decorate([
-    (0, typescript_mix_1.use)(SqlWhereCompiler, orm_1.TableAliasCompiler),
+    use(SqlWhereCompiler, TableAliasCompiler),
     __metadata("design:type", Object)
 ], SqlUpdateQueryCompiler.prototype, "this", void 0);
 SqlUpdateQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [Object, orm_1.UpdateQueryBuilder])
+    NewInstance(),
+    __metadata("design:paramtypes", [Object, UpdateQueryBuilder])
 ], SqlUpdateQueryCompiler);
-exports.SqlUpdateQueryCompiler = SqlUpdateQueryCompiler;
+export { SqlUpdateQueryCompiler };
 let SqlDeleteQueryCompiler = class SqlDeleteQueryCompiler extends SqlQueryCompiler {
     constructor(_container, builder) {
         super(builder, _container);
@@ -353,23 +346,23 @@ let SqlDeleteQueryCompiler = class SqlDeleteQueryCompiler extends SqlQueryCompil
         };
     }
     limit() {
-        const compiler = this._container.resolve(orm_1.LimitQueryCompiler, [this._builder]);
+        const compiler = this._container.resolve(LimitQueryCompiler, [this._builder]);
         return compiler.compile();
     }
     from() {
-        return `DELETE FROM ${this._container.resolve(orm_1.TableAliasCompiler).compile(this._builder)}`;
+        return `DELETE FROM ${this._container.resolve(TableAliasCompiler).compile(this._builder)}`;
     }
 };
 __decorate([
-    (0, typescript_mix_1.use)(SqlWhereCompiler, orm_1.TableAliasCompiler),
+    use(SqlWhereCompiler, TableAliasCompiler),
     __metadata("design:type", Object)
 ], SqlDeleteQueryCompiler.prototype, "this", void 0);
 SqlDeleteQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [Object, orm_1.DeleteQueryBuilder])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, DeleteQueryBuilder])
 ], SqlDeleteQueryCompiler);
-exports.SqlDeleteQueryCompiler = SqlDeleteQueryCompiler;
+export { SqlDeleteQueryCompiler };
 let SqlOnDuplicateQueryCompiler = class SqlOnDuplicateQueryCompiler {
     constructor(builder) {
         this._builder = builder;
@@ -378,7 +371,7 @@ let SqlOnDuplicateQueryCompiler = class SqlOnDuplicateQueryCompiler {
         const columns = this._builder
             .getColumnsToUpdate()
             .map((c) => {
-            if (lodash_1.default.isString(c)) {
+            if (_.isString(c)) {
                 return `\`${c}\` = ?`;
             }
             else {
@@ -391,7 +384,7 @@ let SqlOnDuplicateQueryCompiler = class SqlOnDuplicateQueryCompiler {
             .getColumns()
             .map((c) => c.Column);
         const bindings = this._builder.getColumnsToUpdate().map((c) => {
-            if (lodash_1.default.isString(c)) {
+            if (_.isString(c)) {
                 return this._builder.getParent().Values[0][valueMap.indexOf(c)];
             }
             else {
@@ -405,11 +398,11 @@ let SqlOnDuplicateQueryCompiler = class SqlOnDuplicateQueryCompiler {
     }
 };
 SqlOnDuplicateQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.OnDuplicateQueryBuilder])
+    NewInstance(),
+    __metadata("design:paramtypes", [OnDuplicateQueryBuilder])
 ], SqlOnDuplicateQueryCompiler);
-exports.SqlOnDuplicateQueryCompiler = SqlOnDuplicateQueryCompiler;
-let SqlIndexQueryCompiler = class SqlIndexQueryCompiler extends orm_1.IndexQueryCompiler {
+export { SqlOnDuplicateQueryCompiler };
+let SqlIndexQueryCompiler = class SqlIndexQueryCompiler extends IndexQueryCompiler {
     constructor(builder) {
         super();
         this._builder = builder;
@@ -422,10 +415,10 @@ let SqlIndexQueryCompiler = class SqlIndexQueryCompiler extends orm_1.IndexQuery
     }
 };
 SqlIndexQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.IndexQueryBuilder])
+    NewInstance(),
+    __metadata("design:paramtypes", [IndexQueryBuilder])
 ], SqlIndexQueryCompiler);
-exports.SqlIndexQueryCompiler = SqlIndexQueryCompiler;
+export { SqlIndexQueryCompiler };
 let SqlInsertQueryCompiler = class SqlInsertQueryCompiler extends SqlQueryCompiler {
     constructor(_container, builder) {
         super(builder, _container);
@@ -442,7 +435,7 @@ let SqlInsertQueryCompiler = class SqlInsertQueryCompiler extends SqlQueryCompil
     }
     upsort() {
         if (this._builder.Update) {
-            return this._container.resolve(orm_1.OnDuplicateQueryCompiler, [this._builder.DuplicateQueryBuilder]).compile();
+            return this._container.resolve(OnDuplicateQueryCompiler, [this._builder.DuplicateQueryBuilder]).compile();
         }
         return {
             bindings: [],
@@ -451,7 +444,7 @@ let SqlInsertQueryCompiler = class SqlInsertQueryCompiler extends SqlQueryCompil
     }
     values() {
         if (this._builder.Values.length === 0) {
-            throw new exceptions_1.InvalidArgument('values count invalid');
+            throw new InvalidArgument('values count invalid');
         }
         const bindings = [];
         let data = 'VALUES ';
@@ -462,7 +455,7 @@ let SqlInsertQueryCompiler = class SqlInsertQueryCompiler extends SqlQueryCompil
                 const descriptor = this._builder.getColumns()[i].Descriptor;
                 if (descriptor) {
                     if (!descriptor.Nullable && (v === null || v === undefined) && !descriptor.AutoIncrement) {
-                        throw new exceptions_1.InvalidArgument(`value column ${descriptor.Name} cannot be null`);
+                        throw new InvalidArgument(`value column ${descriptor.Name} cannot be null`);
                     }
                     if (descriptor.AutoIncrement && descriptor.PrimaryKey)
                         return false;
@@ -499,28 +492,28 @@ let SqlInsertQueryCompiler = class SqlInsertQueryCompiler extends SqlQueryCompil
             return c.Column;
         })
             .map((c) => {
-            return `\`${c instanceof orm_1.RawQuery ? c.Query : c}\``;
+            return `\`${c instanceof RawQuery ? c.Query : c}\``;
         });
         if (columns.length === 0) {
-            throw new exceptions_1.InvalidArgument('invalid column count');
+            throw new InvalidArgument('invalid column count');
         }
         return `(` + columns.join(',') + ')';
     }
     into() {
-        return `INSERT${this._builder.Ignore ? ' IGNORE' : ''} INTO ${this._container.resolve(orm_1.TableAliasCompiler).compile(this._builder)}`;
+        return `INSERT${this._builder.Ignore ? ' IGNORE' : ''} INTO ${this._container.resolve(TableAliasCompiler).compile(this._builder)}`;
     }
 };
 __decorate([
-    (0, typescript_mix_1.use)(orm_1.TableAliasCompiler),
+    use(TableAliasCompiler),
     __metadata("design:type", Object)
 ], SqlInsertQueryCompiler.prototype, "this", void 0);
 SqlInsertQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [Object, orm_1.InsertQueryBuilder])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, InsertQueryBuilder])
 ], SqlInsertQueryCompiler);
-exports.SqlInsertQueryCompiler = SqlInsertQueryCompiler;
-let SqlDropTableQueryCompiler = class SqlDropTableQueryCompiler extends orm_1.DropTableCompiler {
+export { SqlInsertQueryCompiler };
+let SqlDropTableQueryCompiler = class SqlDropTableQueryCompiler extends DropTableCompiler {
     constructor(container, builder) {
         super();
         this.container = container;
@@ -528,7 +521,7 @@ let SqlDropTableQueryCompiler = class SqlDropTableQueryCompiler extends orm_1.Dr
     }
     compile() {
         const exists = this.builder.Exists ? ' IF EXISTS' : '';
-        const exprr = `DROP TABLE${exists} ${this.container.resolve(orm_1.TableAliasCompiler).compile(this.builder)}`;
+        const exprr = `DROP TABLE${exists} ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
         return {
             bindings: [],
             expression: exprr,
@@ -536,12 +529,12 @@ let SqlDropTableQueryCompiler = class SqlDropTableQueryCompiler extends orm_1.Dr
     }
 };
 SqlDropTableQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, orm_1.DropTableQueryBuilder])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, DropTableQueryBuilder])
 ], SqlDropTableQueryCompiler);
-exports.SqlDropTableQueryCompiler = SqlDropTableQueryCompiler;
-let SqlAlterTableQueryCompiler = class SqlAlterTableQueryCompiler extends orm_1.AlterTableQueryCompiler {
+export { SqlDropTableQueryCompiler };
+let SqlAlterTableQueryCompiler = class SqlAlterTableQueryCompiler extends AlterTableQueryCompiler {
     constructor(container, builder) {
         super();
         this.container = container;
@@ -561,12 +554,12 @@ let SqlAlterTableQueryCompiler = class SqlAlterTableQueryCompiler extends orm_1.
         if (this.builder.NewTableName) {
             _outputs.push({
                 bindings: [],
-                expression: `${_table} RENAME TO ${this.container.resolve(orm_1.TableAliasCompiler).compile(this.builder, this.builder.NewTableName)}`,
+                expression: `${_table} RENAME TO ${this.container.resolve(TableAliasCompiler).compile(this.builder, this.builder.NewTableName)}`,
             });
         }
         if (this.builder.Columns.length !== 0) {
             _outputs = _outputs.concat(this.builder.Columns.map((c) => {
-                const compiler = this.container.resolve(orm_1.AlterColumnQueryCompiler, [c]).compile();
+                const compiler = this.container.resolve(AlterColumnQueryCompiler, [c]).compile();
                 return {
                     bindings: compiler.bindings,
                     expression: `${_table} ${compiler.expression}`,
@@ -576,23 +569,23 @@ let SqlAlterTableQueryCompiler = class SqlAlterTableQueryCompiler extends orm_1.
         return _outputs;
     }
     _table() {
-        return `ALTER TABLE ${this.container.resolve(orm_1.TableAliasCompiler).compile(this.builder)}`;
+        return `ALTER TABLE ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
     }
 };
 SqlAlterTableQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, orm_1.AlterTableQueryBuilder])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, AlterTableQueryBuilder])
 ], SqlAlterTableQueryCompiler);
-exports.SqlAlterTableQueryCompiler = SqlAlterTableQueryCompiler;
-let SqlTableCloneQueryCompiler = class SqlTableCloneQueryCompiler extends orm_1.TableCloneQueryCompiler {
+export { SqlAlterTableQueryCompiler };
+let SqlTableCloneQueryCompiler = class SqlTableCloneQueryCompiler extends TableCloneQueryCompiler {
     constructor(container, builder) {
         super();
         this.container = container;
         this.builder = builder;
     }
     compile() {
-        const _tblName = this.container.resolve(orm_1.TableAliasCompiler).compile(this.builder, this.builder.CloneSource);
+        const _tblName = this.container.resolve(TableAliasCompiler).compile(this.builder, this.builder.CloneSource);
         const _table = this._table();
         const out1 = {
             bindings: [],
@@ -618,20 +611,20 @@ let SqlTableCloneQueryCompiler = class SqlTableCloneQueryCompiler extends orm_1.
         return [out1];
     }
     _table() {
-        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.container.resolve(orm_1.TableAliasCompiler).compile(this.builder)}`;
+        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
     }
 };
 __decorate([
-    (0, typescript_mix_1.use)(orm_1.TableAliasCompiler),
+    use(TableAliasCompiler),
     __metadata("design:type", Object)
 ], SqlTableCloneQueryCompiler.prototype, "this", void 0);
 SqlTableCloneQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, orm_1.CloneTableQueryBuilder])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, CloneTableQueryBuilder])
 ], SqlTableCloneQueryCompiler);
-exports.SqlTableCloneQueryCompiler = SqlTableCloneQueryCompiler;
-class SqlTruncateTableQueryCompiler extends orm_1.TableQueryCompiler {
+export { SqlTableCloneQueryCompiler };
+export class SqlTruncateTableQueryCompiler extends TableQueryCompiler {
     constructor(container, builder) {
         super();
         this.container = container;
@@ -640,19 +633,18 @@ class SqlTruncateTableQueryCompiler extends orm_1.TableQueryCompiler {
     compile() {
         return {
             bindings: [],
-            expression: `TRUNCATE TABLE ${this.container.resolve(orm_1.TableAliasCompiler).compile(this.builder)}`,
+            expression: `TRUNCATE TABLE ${this.container.resolve(TableAliasCompiler).compile(this.builder)}`,
         };
     }
 }
-exports.SqlTruncateTableQueryCompiler = SqlTruncateTableQueryCompiler;
-let SqlTableHistoryQueryCompiler = class SqlTableHistoryQueryCompiler extends orm_1.TableHistoryQueryCompiler {
+let SqlTableHistoryQueryCompiler = class SqlTableHistoryQueryCompiler extends TableHistoryQueryCompiler {
     constructor(container, builder) {
         super();
         this.container = container;
         this.builder = builder;
     }
     compile() {
-        const tblAliasCompiler = this.container.resolve(orm_1.TableAliasCompiler);
+        const tblAliasCompiler = this.container.resolve(TableAliasCompiler);
         const hTtblName = tblAliasCompiler.compile(this.builder, `${this.builder.Table}__history`);
         const tblName = tblAliasCompiler.compile(this.builder, `${this.builder.Table}`);
         const hTriggerName = `${this.builder.Table}__history`;
@@ -744,12 +736,12 @@ let SqlTableHistoryQueryCompiler = class SqlTableHistoryQueryCompiler extends or
     }
 };
 SqlTableHistoryQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, orm_1.TableQueryBuilder])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, TableQueryBuilder])
 ], SqlTableHistoryQueryCompiler);
-exports.SqlTableHistoryQueryCompiler = SqlTableHistoryQueryCompiler;
-let SqlTableQueryCompiler = class SqlTableQueryCompiler extends orm_1.TableQueryCompiler {
+export { SqlTableHistoryQueryCompiler };
+let SqlTableQueryCompiler = class SqlTableQueryCompiler extends TableQueryCompiler {
     constructor(container, builder) {
         super();
         this.container = container;
@@ -765,7 +757,7 @@ let SqlTableQueryCompiler = class SqlTableQueryCompiler extends orm_1.TableQuery
             expression: `${_table} (${_columns} ${_primaryKey ? ',' + _primaryKey : ''} ${_keys ? ',' + _keys : ''})`,
         };
         if (this.builder.TrackHistory) {
-            const hCompiler = this.container.resolve(orm_1.TableHistoryQueryCompiler, [this.builder]);
+            const hCompiler = this.container.resolve(TableHistoryQueryCompiler, [this.builder]);
             return [createOutput, ...hCompiler.compile()];
         }
         else {
@@ -774,33 +766,33 @@ let SqlTableQueryCompiler = class SqlTableQueryCompiler extends orm_1.TableQuery
     }
     _columns() {
         return this.builder.Columns.map((c) => {
-            return this.container.resolve(orm_1.ColumnQueryCompiler, [c]).compile().expression;
+            return this.container.resolve(ColumnQueryCompiler, [c]).compile().expression;
         }).join(',');
     }
     _foreignKeys() {
         return this.builder.ForeignKeys.map((f) => {
-            return this.container.resolve(orm_1.ForeignKeyQueryCompiler, [f]).compile().expression;
+            return this.container.resolve(ForeignKeyQueryCompiler, [f]).compile().expression;
         }).join(',');
     }
     _primaryKeys() {
         const _keys = this.builder.Columns.filter((x) => x.PrimaryKey)
             .map((c) => `\`${c.Name}\``)
             .join(',');
-        if (!lodash_1.default.isEmpty(_keys)) {
+        if (!_.isEmpty(_keys)) {
             return `PRIMARY KEY (${_keys})`;
         }
         return '';
     }
     _table() {
-        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.builder.CheckExists ? 'IF NOT EXISTS ' : ''}${this.container.resolve(orm_1.TableAliasCompiler).compile(this.builder)}`;
+        return `CREATE${this.builder.Temporary ? ' TEMPORARY ' : ' '}TABLE ${this.builder.CheckExists ? 'IF NOT EXISTS ' : ''}${this.container.resolve(TableAliasCompiler).compile(this.builder)}`;
     }
 };
 SqlTableQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [di_1.Container, orm_1.TableQueryBuilder])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Container, TableQueryBuilder])
 ], SqlTableQueryCompiler);
-exports.SqlTableQueryCompiler = SqlTableQueryCompiler;
+export { SqlTableQueryCompiler };
 let SqlColumnQueryCompiler = class SqlColumnQueryCompiler {
     constructor(builder) {
         this.builder = builder;
@@ -816,7 +808,7 @@ let SqlColumnQueryCompiler = class SqlColumnQueryCompiler {
             double: (builder) => this._statementsMappings.float(builder),
             decimal: (builder) => this._statementsMappings.float(builder),
             enum: (builder) => `${builder.Type.toUpperCase()}(${builder.Args[0].map((a) => `'${a}'`).join(',')})`,
-            binary: (builder) => { var _a; return `BINARY(${(_a = builder.Args[0]) !== null && _a !== void 0 ? _a : 255}`; },
+            binary: (builder) => `BINARY(${builder.Args[0] ?? 255}`,
             smallint: (builder) => builder.Type.toUpperCase(),
             tinyint: (builder) => builder.Type.toUpperCase(),
             mediumint: (builder) => builder.Type.toUpperCase(),
@@ -878,38 +870,38 @@ let SqlColumnQueryCompiler = class SqlColumnQueryCompiler {
         }
         return {
             bindings: [],
-            expression: _stmt.filter((x) => !lodash_1.default.isEmpty(x)).join(' '),
+            expression: _stmt.filter((x) => !_.isEmpty(x)).join(' '),
         };
     }
     _defaultCompiler() {
         let _stmt = '';
-        if (lodash_1.default.isNil(this.builder.Default) || (lodash_1.default.isNil(this.builder.Default.Query) && lodash_1.default.isNil(this.builder.Default.Value))) {
+        if (_.isNil(this.builder.Default) || (_.isNil(this.builder.Default.Query) && _.isNil(this.builder.Default.Value))) {
             return _stmt;
         }
-        if (lodash_1.default.isString(this.builder.Default.Value)) {
+        if (_.isString(this.builder.Default.Value)) {
             _stmt = `DEFAULT '${this.builder.Default.Value.trim()}'`;
         }
-        else if (lodash_1.default.isNumber(this.builder.Default.Value)) {
+        else if (_.isNumber(this.builder.Default.Value)) {
             _stmt = `DEFAULT ${this.builder.Default.Value}`;
         }
-        else if (this.builder.Default.Query instanceof orm_1.RawQuery) {
+        else if (this.builder.Default.Query instanceof RawQuery) {
             _stmt = `DEFAULT ${this.builder.Default.Query.Query}`;
         }
         return _stmt;
     }
 };
 SqlColumnQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.ColumnQueryBuilder])
+    NewInstance(),
+    __metadata("design:paramtypes", [ColumnQueryBuilder])
 ], SqlColumnQueryCompiler);
-exports.SqlColumnQueryCompiler = SqlColumnQueryCompiler;
+export { SqlColumnQueryCompiler };
 let SqlAlterColumnQueryCompiler = class SqlAlterColumnQueryCompiler extends SqlColumnQueryCompiler {
     constructor(builder) {
         super(builder);
     }
     compile() {
         const builder = this.builder;
-        if (builder.AlterType === orm_1.ColumnAlterationType.Rename) {
+        if (builder.AlterType === ColumnAlterationType.Rename) {
             const bld = this.builder;
             return {
                 bindings: [],
@@ -917,13 +909,13 @@ let SqlAlterColumnQueryCompiler = class SqlAlterColumnQueryCompiler extends SqlC
             };
         }
         const cDefinition = super.compile();
-        if (builder.AlterType === orm_1.ColumnAlterationType.Add) {
+        if (builder.AlterType === ColumnAlterationType.Add) {
             return {
                 bindings: cDefinition.bindings,
                 expression: `ADD ${cDefinition.expression} ${builder.AfterColumn ? `AFTER \`${builder.AfterColumn}\`` : ''}`,
             };
         }
-        if (builder.AlterType === orm_1.ColumnAlterationType.Modify) {
+        if (builder.AlterType === ColumnAlterationType.Modify) {
             return {
                 bindings: cDefinition.bindings,
                 expression: `MODIFY ${cDefinition.expression}`,
@@ -932,10 +924,10 @@ let SqlAlterColumnQueryCompiler = class SqlAlterColumnQueryCompiler extends SqlC
     }
 };
 SqlAlterColumnQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    __metadata("design:paramtypes", [orm_1.AlterColumnQueryBuilder])
+    NewInstance(),
+    __metadata("design:paramtypes", [AlterColumnQueryBuilder])
 ], SqlAlterColumnQueryCompiler);
-exports.SqlAlterColumnQueryCompiler = SqlAlterColumnQueryCompiler;
+export { SqlAlterColumnQueryCompiler };
 let SqlEventQueryCompiler = class SqlEventQueryCompiler extends SqlQueryCompiler {
     constructor(container, builder) {
         super(builder, container);
@@ -1003,11 +995,11 @@ let SqlEventQueryCompiler = class SqlEventQueryCompiler extends SqlQueryCompiler
     }
 };
 SqlEventQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [Object, orm_1.EventQueryBuilder])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, EventQueryBuilder])
 ], SqlEventQueryCompiler);
-exports.SqlEventQueryCompiler = SqlEventQueryCompiler;
+export { SqlEventQueryCompiler };
 let SqlDropEventQueryCompiler = class SqlDropEventQueryCompiler extends SqlQueryCompiler {
     constructor(container, builder) {
         super(builder, container);
@@ -1020,9 +1012,9 @@ let SqlDropEventQueryCompiler = class SqlDropEventQueryCompiler extends SqlQuery
     }
 };
 SqlDropEventQueryCompiler = __decorate([
-    (0, di_1.NewInstance)(),
-    (0, di_1.Inject)(di_1.Container),
-    __metadata("design:paramtypes", [Object, orm_1.DropEventQueryBuilder])
+    NewInstance(),
+    Inject(Container),
+    __metadata("design:paramtypes", [Object, DropEventQueryBuilder])
 ], SqlDropEventQueryCompiler);
-exports.SqlDropEventQueryCompiler = SqlDropEventQueryCompiler;
+export { SqlDropEventQueryCompiler };
 //# sourceMappingURL=compilers.js.map