@spinajs/orm 1.0.60 → 1.2.32

package/lib/orm/src/builders.js

@@ -0,0 +1,1082 @@
+"use strict";
+/* eslint-disable prettier/prettier */
+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 __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.TableQueryBuilder = exports.ColumnQueryBuilder = exports.ForeignKeyBuilder = exports.IndexQueryBuilder = exports.InsertQueryBuilder = exports.UpdateQueryBuilder = exports.OnDuplicateQueryBuilder = exports.DeleteQueryBuilder = exports.SelectQueryBuilder = exports.WhereBuilder = exports.WithRecursiveBuilder = exports.JoinBuilder = exports.GroupByBuilder = exports.RawQuery = exports.ColumnsBuilder = exports.OrderByBuilder = exports.LimitBuilder = exports.QueryBuilder = exports.Builder = void 0;
+const di_1 = require("@spinajs/di");
+const exceptions_1 = require("@spinajs/exceptions");
+const _ = 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");
+function isWhereOperator(val) {
+    return _.isString(val) && Object.values(enums_1.WhereOperators).includes(val.toLowerCase());
+}
+let Builder = class Builder {
+    constructor(container, driver, model) {
+        this._middlewares = [];
+        this._driver = driver;
+        this._container = container;
+        this._model = model;
+        this._nonSelect = true;
+        this._asRaw = false;
+    }
+    middleware(middleware) {
+        this._middlewares.push(middleware);
+        return this;
+    }
+    /**
+     * Builds query that is ready to use in DB
+     */
+    toDB() {
+        throw new exceptions_1.MethodNotImplemented();
+    }
+    then(resolve, reject) {
+        const compiled = this.toDB();
+        return this._driver.execute(compiled.expression, compiled.bindings, this._queryContext).then((result) => {
+            try {
+                if (this._asRaw) {
+                    resolve(result);
+                    return;
+                }
+                if (this._model && !this._nonSelect) {
+                    let transformedResult = result;
+                    if (this._middlewares.length > 0) {
+                        transformedResult = this._middlewares.reduce((_, current) => {
+                            return current.afterData(result);
+                        }, []);
+                    }
+                    const models = transformedResult.map((r) => {
+                        let model = null;
+                        for (const middleware of this._middlewares) {
+                            model = middleware.modelCreation(r);
+                            if (model !== null) {
+                                break;
+                            }
+                        }
+                        if (model === null) {
+                            model = new this._model();
+                            model.hydrate(r);
+                        }
+                        return model;
+                    });
+                    const afterMiddlewarePromises = this._middlewares.reduce((prev, current) => {
+                        return prev.concat([current.afterHydration(models)]);
+                    }, []);
+                    if (this._middlewares.length > 0) {
+                        Promise.all(afterMiddlewarePromises).then(() => {
+                            resolve(models);
+                        }, reject);
+                    }
+                    else {
+                        resolve(models);
+                    }
+                }
+                else {
+                    resolve(result);
+                }
+            }
+            catch (err) {
+                reject(err);
+            }
+        }, reject);
+    }
+};
+Builder = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [di_1.Container, driver_1.OrmDriver, Object])
+], Builder);
+exports.Builder = Builder;
+/**
+ * Base class for queires. Implements basic query functionality
+ *
+ */
+let QueryBuilder = class QueryBuilder extends Builder {
+    constructor(container, driver, model) {
+        super(container, driver, model);
+    }
+    /**
+     * SQL table name that query is executed on
+     *
+     * @example
+     * SELECT * FROM `users`
+     */
+    get Table() {
+        return this._table;
+    }
+    /**
+     * DB table alias
+     */
+    get TableAlias() {
+        return this._tableAlias;
+    }
+    /**
+     * SQL schema/database name that query is executed on.
+     *
+     * @example
+     * SELECT * FROM `spinejs`.`users` as u
+     */
+    get Schema() {
+        return this._schema;
+    }
+    /**
+     * Sets schema to this query.
+     *
+     * @param schema - schema or database name in database
+     */
+    schema(schema) {
+        if (!schema) {
+            throw new exceptions_1.InvalidArgument(`schema argument cannot be null or empty`);
+        }
+        this._schema = schema;
+        return this;
+    }
+    /**
+     * Sets table that query is executed on
+     *
+     * @param table - sql table name
+     * @param alias - sql table alias
+     *
+     * @example
+     *
+     * this.setTable("user","u")
+     *
+     */
+    setTable(table, alias) {
+        if (!table.trim()) {
+            throw new exceptions_1.InvalidArgument('table name is empty');
+        }
+        this._table = table;
+        this.setAlias(alias);
+        return this;
+    }
+    /**
+     * Sets table alias for query
+     *
+     * @param alias - sql table alias
+     */
+    setAlias(alias) {
+        this._tableAlias = alias;
+        return this;
+    }
+    from(table, alias) {
+        return this.setTable(table, alias);
+    }
+};
+QueryBuilder = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [di_1.Container, driver_1.OrmDriver, Object])
+], QueryBuilder);
+exports.QueryBuilder = QueryBuilder;
+let LimitBuilder = class LimitBuilder {
+    constructor() {
+        this._fail = false;
+        this._first = false;
+        this._limit = {
+            limit: -1,
+            offset: -1,
+        };
+    }
+    take(count) {
+        if (count <= 0) {
+            throw new exceptions_1.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`);
+        }
+        this._limit.offset = count;
+        return this;
+    }
+    async first() {
+        this._first = true;
+        this._limit.limit = 1;
+        return (await this);
+    }
+    firstOrFail() {
+        this._fail = true;
+        return this.first();
+    }
+    getLimits() {
+        return this._limit;
+    }
+};
+LimitBuilder = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [])
+], LimitBuilder);
+exports.LimitBuilder = LimitBuilder;
+let OrderByBuilder = class OrderByBuilder {
+    constructor() {
+        this._sort = {
+            column: '',
+            order: enums_1.SORT_ORDER.ASC,
+        };
+    }
+    order(column, direction) {
+        this._sort = {
+            column,
+            order: direction,
+        };
+        return this;
+    }
+    orderBy(column) {
+        this._sort = {
+            column,
+            order: enums_1.SORT_ORDER.ASC,
+        };
+        return this;
+    }
+    orderByDescending(column) {
+        this._sort = {
+            column,
+            order: enums_1.SORT_ORDER.DESC,
+        };
+        return this;
+    }
+    getSort() {
+        return this._sort.column.trim() !== '' ? this._sort : null;
+    }
+};
+OrderByBuilder = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [])
+], OrderByBuilder);
+exports.OrderByBuilder = OrderByBuilder;
+let ColumnsBuilder = class ColumnsBuilder {
+    constructor() {
+        this._columns = [];
+    }
+    /**
+     * Clears all select clauses from the query.
+     *
+     * @example
+     *
+     * query.columns()
+     *
+     */
+    clearColumns() {
+        this._columns = [];
+        return this;
+    }
+    columns(names) {
+        const descriptor = (0, model_1.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;
+    }
+    select(column, alias) {
+        const descriptor = (0, model_1.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)]));
+            });
+        }
+        if (column instanceof RawQuery) {
+            this._columns.push(this._container.resolve(statements_1.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)]));
+        }
+        return this;
+    }
+    getColumns() {
+        return this._columns;
+    }
+};
+ColumnsBuilder = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [])
+], ColumnsBuilder);
+exports.ColumnsBuilder = 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;
+    }
+    get Bindings() {
+        return this._bindings;
+    }
+    static create(query, bindings) {
+        return new RawQuery_1(query, bindings);
+    }
+};
+RawQuery = RawQuery_1 = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [String, Array])
+], RawQuery);
+exports.RawQuery = RawQuery;
+class GroupByBuilder {
+    constructor() {
+        this._groupStatements = [];
+    }
+    get GroupStatements() {
+        return this._groupStatements;
+    }
+    clearGroupBy() {
+        this._groupStatements = [];
+        return this;
+    }
+    groupBy(expression) {
+        this._groupStatements.push(this._container.resolve(statements_1.GroupByStatement, [expression]));
+        return this;
+    }
+}
+exports.GroupByBuilder = GroupByBuilder;
+class JoinBuilder {
+    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);
+        return this;
+    }
+    leftJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
+        this.addJoinStatement.call(this, enums_1.JoinMethod.LEFT, ...arguments);
+        return this;
+    }
+    leftOuterJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
+        this.addJoinStatement.call(this, enums_1.JoinMethod.LEFT_OUTER, ...arguments);
+        return this;
+    }
+    rightJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
+        this.addJoinStatement.call(this, enums_1.JoinMethod.RIGHT, ...arguments);
+        return this;
+    }
+    rightOuterJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
+        this.addJoinStatement.call(this, enums_1.JoinMethod.RIGHT_OUTER, ...arguments);
+        return this;
+    }
+    fullOuterJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
+        this.addJoinStatement.call(this, enums_1.JoinMethod.FULL_OUTER, ...arguments);
+        return this;
+    }
+    crossJoin(_table, _AliasOrForeignKey, _fkOrPkKey, _primaryKey) {
+        this.addJoinStatement.call(this, enums_1.JoinMethod.CROSS, ...arguments);
+        return this;
+    }
+    addJoinStatement(method, table, AliasOrForeignKey, fkOrPkKey, primaryKey) {
+        let stmt = null;
+        if (arguments.length === 4) {
+            stmt = this._container.resolve(statements_1.JoinStatement, [table, method, AliasOrForeignKey, fkOrPkKey, null, this._tableAlias]);
+        }
+        else if (arguments.length === 5) {
+            stmt = this._container.resolve(statements_1.JoinStatement, [table, method, fkOrPkKey, primaryKey, AliasOrForeignKey, this._tableAlias]);
+        }
+        else {
+            stmt = this._container.resolve(statements_1.JoinStatement, [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]);
+        return this;
+    }
+};
+WithRecursiveBuilder = __decorate([
+    (0, di_1.NewInstance)()
+], WithRecursiveBuilder);
+exports.WithRecursiveBuilder = 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;
+    }
+    where(column, operator, value) {
+        const self = this;
+        // Support "where true || where false"
+        if (_.isBoolean(column)) {
+            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]));
+            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]));
+            return this;
+        }
+        // handle simple key = object[key] AND ....
+        if (_.isObject(column) && !(column instanceof statements_1.Wrap)) {
+            return this.whereObject(column);
+        }
+        if (typeof value === 'undefined') {
+            return _handleForTwo.call(this, column, operator);
+        }
+        return _handleForThree.call(this, column, operator, value);
+        /**
+         * handles for where("foo", 1).where(...) cases
+         * it produces WHERE foo = 1
+         */
+        function _handleForTwo(c, v) {
+            if (v === undefined) {
+                throw new exceptions_1.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 (v === null) {
+                return this.whereNull(c);
+            }
+            self._statements.push(self._container.resolve(statements_1.WhereStatement, [c, enums_1.WhereOperators.EQ, v, self._tableAlias, this._container]));
+            return self;
+        }
+        /**
+         * Handles for where("foo",'!=',1) etc
+         * it produces WHERE foo != 1
+         */
+        function _handleForThree(c, o, v) {
+            if (!isWhereOperator(o)) {
+                throw new exceptions_1.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 (v === null) {
+                return this.whereNull(c);
+            }
+            if (v === null) {
+                return o === enums_1.WhereOperators.NOT_NULL ? this.whereNotNull(c) : this.whereNull(c);
+            }
+            self._statements.push(self._container.resolve(statements_1.WhereStatement, [c, o, v, self._tableAlias, this._container]));
+            return this;
+        }
+    }
+    orWhere(column, ..._args) {
+        this._boolean = enums_1.WhereBoolean.OR;
+        return this.where(column, ...Array.from(arguments).slice(1));
+    }
+    andWhere(column, ..._args) {
+        this._boolean = enums_1.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.WhereOperators.EQ, obj[key]);
+        }
+        return this;
+    }
+    whereNotNull(column) {
+        this._statements.push(this._container.resolve(statements_1.WhereStatement, [column, enums_1.WhereOperators.NOT_NULL, null, this._tableAlias]));
+        return this;
+    }
+    whereNull(column) {
+        this._statements.push(this._container.resolve(statements_1.WhereStatement, [column, enums_1.WhereOperators.NULL, null, this._tableAlias]));
+        return this;
+    }
+    whereNot(column, val) {
+        return this.where(column, enums_1.WhereOperators.NOT, val);
+    }
+    whereIn(column, val) {
+        this._statements.push(this._container.resolve(statements_1.InStatement, [column, val, false, this._tableAlias]));
+        return this;
+    }
+    whereNotIn(column, val) {
+        this._statements.push(this._container.resolve(statements_1.InStatement, [column, val, true, this._tableAlias]));
+        return this;
+    }
+    whereExist(query) {
+        this._statements.push(this._container.resolve(statements_1.ExistsQueryStatement, [query, false]));
+        return this;
+    }
+    whereNotExists(query) {
+        this._statements.push(this._container.resolve(statements_1.ExistsQueryStatement, [query, true]));
+        return this;
+    }
+    whereBetween(column, val) {
+        this._statements.push(this._container.resolve(statements_1.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]));
+        return this;
+    }
+    whereInSet(column, val) {
+        this._statements.push(this._container.resolve(statements_1.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]));
+        return this;
+    }
+    clearWhere() {
+        this._statements = [];
+        return this;
+    }
+};
+WhereBuilder = WhereBuilder_1 = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [di_1.Container, String])
+], WhereBuilder);
+exports.WhereBuilder = WhereBuilder;
+class SelectQueryBuilder extends QueryBuilder {
+    constructor(container, driver, model, owner) {
+        super(container, driver, model);
+        this._columns = [];
+        /**
+         * where query props
+         */
+        this._statements = [];
+        this._joinStatements = [];
+        this._groupStatements = [];
+        this._relations = [];
+        this._distinct = false;
+        this._method = enums_1.QueryMethod.SELECT;
+        this._boolean = enums_1.WhereBoolean.AND;
+        this._sort = {
+            column: '',
+            order: enums_1.SORT_ORDER.ASC,
+        };
+        this._first = false;
+        this._limit = {
+            limit: -1,
+            offset: -1,
+        };
+        this._nonSelect = false;
+        this._queryContext = interfaces_1.QueryContext.Select;
+        this._owner = owner;
+    }
+    get IsDistinct() {
+        return this._distinct;
+    }
+    get Owner() {
+        return this._owner;
+    }
+    get Relations() {
+        return this._relations;
+    }
+    async asRaw() {
+        this._asRaw = true;
+        return (await this);
+    }
+    setAlias(alias) {
+        this._tableAlias = alias;
+        this._columns.forEach((c) => (c.TableAlias = alias));
+        this._joinStatements.forEach((c) => (c.TableAlias = alias));
+        this._statements.forEach((c) => (c.TableAlias = alias));
+        return this;
+    }
+    clone() {
+        const builder = new SelectQueryBuilder(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._boolean = this._boolean;
+        builder._distinct = this._distinct;
+        builder._table = this._table;
+        builder._tableAlias = this._tableAlias;
+        return builder;
+    }
+    populate(relation, callback) {
+        var _a;
+        let relInstance = null;
+        const descriptor = (0, model_1.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}`);
+        }
+        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]);
+        }
+        else {
+            if (relDescription.Recursive) {
+                throw new exceptions_1.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]);
+                    break;
+                case interfaces_1.RelationType.Many:
+                    relInstance = this._container.resolve(relations_1.OneToManyRelation, [this._container.get(orm_1.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]);
+                    break;
+            }
+        }
+        relInstance.execute(callback);
+        this._relations.push(relInstance);
+        return this;
+    }
+    mergeStatements(builder) {
+        this._joinStatements = this._joinStatements.concat(builder._joinStatements);
+        this._columns = this._columns.concat(builder._columns);
+        this._statements = this._statements.concat(builder._statements);
+        this._relations = this._relations.concat(builder._relations);
+        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]));
+        return this;
+    }
+    max(column, as) {
+        this._columns.push(this._container.resolve(statements_1.ColumnMethodStatement, [column, enums_1.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]));
+        return this;
+    }
+    sum(column, as) {
+        this._columns.push(this._container.resolve(statements_1.ColumnMethodStatement, [column, enums_1.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]));
+        return this;
+    }
+    distinct() {
+        if (this._columns.length === 0 || this._columns[0].IsWildcard) {
+            throw new exceptions_1.InvalidOperation('Cannot force DISTINCT on unknown column');
+        }
+        this._distinct = true;
+        return this;
+    }
+    toDB() {
+        const compiler = this._container.resolve(interfaces_1.SelectQueryCompiler, [this]);
+        return compiler.compile();
+    }
+    then(resolve, reject) {
+        return super.then((result) => {
+            if (this._first) {
+                if (this._fail && result.length === 0) {
+                    reject(new Error('empty results'));
+                }
+                else {
+                    resolve(result ? result[0] : null);
+                }
+            }
+            else {
+                resolve(result);
+            }
+        }, reject);
+    }
+    async execute() {
+        return (await this);
+    }
+}
+__decorate([
+    (0, typescript_mix_1.use)(WhereBuilder, LimitBuilder, OrderByBuilder, ColumnsBuilder, JoinBuilder, WithRecursiveBuilder, GroupByBuilder),
+    __metadata("design:type", Object)
+], SelectQueryBuilder.prototype, "this", void 0);
+exports.SelectQueryBuilder = SelectQueryBuilder;
+class DeleteQueryBuilder extends QueryBuilder {
+    constructor(container, driver, model) {
+        super(container, driver, model);
+        this._truncate = false;
+        this._method = enums_1.QueryMethod.DELETE;
+        this._statements = [];
+        this._boolean = enums_1.WhereBoolean.AND;
+        this._limit = {
+            limit: -1,
+            offset: -1,
+        };
+        this._queryContext = interfaces_1.QueryContext.Delete;
+    }
+    get Truncate() {
+        return this._truncate;
+    }
+    toDB() {
+        return this._container.resolve(interfaces_1.DeleteQueryCompiler, [this]).compile();
+    }
+    truncate() {
+        this._truncate = true;
+        return this;
+    }
+}
+__decorate([
+    (0, typescript_mix_1.use)(WhereBuilder, LimitBuilder),
+    __metadata("design:type", Object)
+], DeleteQueryBuilder.prototype, "this", void 0);
+exports.DeleteQueryBuilder = DeleteQueryBuilder;
+class OnDuplicateQueryBuilder {
+    constructor(container, insertQueryBuilder, column) {
+        this._parent = insertQueryBuilder;
+        this._container = container;
+        this._column = _.isArray(column) ? column : [column];
+    }
+    getColumn() {
+        return this._column;
+    }
+    getColumnsToUpdate() {
+        return this._columnsToUpdate;
+    }
+    getParent() {
+        return this._parent;
+    }
+    update(columns) {
+        this._columnsToUpdate = columns;
+        return this;
+    }
+    then(resolve, reject) {
+        return this._parent.then(resolve, reject);
+    }
+    toDB() {
+        return this._parent.toDB();
+    }
+}
+exports.OnDuplicateQueryBuilder = OnDuplicateQueryBuilder;
+class UpdateQueryBuilder extends QueryBuilder {
+    constructor(container, driver, model) {
+        super(container, driver, model);
+        this._value = {};
+        this._method = enums_1.QueryMethod.UPDATE;
+        this._boolean = enums_1.WhereBoolean.AND;
+        this._statements = [];
+        this._queryContext = interfaces_1.QueryContext.Update;
+    }
+    get Value() {
+        return this._value;
+    }
+    in(name) {
+        this.setTable(name);
+        return this;
+    }
+    update(value) {
+        this._value = value;
+        return this;
+    }
+    toDB() {
+        return this._container.resolve(interfaces_1.UpdateQueryCompiler, [this]).compile();
+    }
+}
+__decorate([
+    (0, typescript_mix_1.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;
+    }
+    get Values() {
+        return this._values;
+    }
+    get Ignore() {
+        return this._ignore;
+    }
+    /**
+     * Sets insert to ignore on duplicate
+     */
+    ignore() {
+        this._ignore = true;
+        return this;
+    }
+    values(data) {
+        const self = this;
+        if (Array.isArray(data)) {
+            this.columns(_.chain(data).map(_.keys).flatten().uniq().value());
+            data.forEach((d) => {
+                _addData(d);
+            });
+        }
+        else {
+            this.columns(_.keysIn(data));
+            _addData(data);
+        }
+        function _addData(d) {
+            const binding = [];
+            self._columns
+                .filter((c) => !(c.Column instanceof RawQuery))
+                .map((c) => {
+                return c.Column;
+            })
+                .forEach((c) => {
+                binding.push(d[c]);
+            });
+            self._values.push(binding);
+        }
+        return this;
+    }
+    into(table, schema) {
+        this.setTable(table, schema);
+        return this;
+    }
+    onDuplicate(column) {
+        let columnToCheck = column;
+        if (!columnToCheck && this.this._model) {
+            columnToCheck = (0, model_1.extractModelDescriptor)(this._model)
+                .Columns.filter((c) => c.Unique && !c.PrimaryKey)
+                .map((c) => c.Name);
+        }
+        this.DuplicateQueryBuilder = new OnDuplicateQueryBuilder(this._container, this, columnToCheck);
+        return this.DuplicateQueryBuilder;
+    }
+    toDB() {
+        return this._container.resolve(interfaces_1.InsertQueryCompiler, [this]).compile();
+    }
+}
+__decorate([
+    (0, typescript_mix_1.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;
+    }
+    name(name) {
+        this.Name = name;
+        return this;
+    }
+    unique() {
+        this.Unique = true;
+        return this;
+    }
+    table(name) {
+        this.Table = name;
+        return this;
+    }
+    columns(colNames) {
+        this.Columns = colNames;
+        return this;
+    }
+    toDB() {
+        return this._container.resolve(interfaces_1.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])
+], IndexQueryBuilder);
+exports.IndexQueryBuilder = IndexQueryBuilder;
+let ForeignKeyBuilder = class ForeignKeyBuilder {
+    constructor() {
+        this.OnDeleteAction = interfaces_1.ReferentialAction.NoAction;
+        this.OnUpdateAction = interfaces_1.ReferentialAction.NoAction;
+    }
+    /**
+     *
+     * Referenced field in child table
+     *
+     * @param fkName - name of foreign field in child table
+     */
+    foreignKey(fkName) {
+        this.ForeignKeyField = fkName;
+        return this;
+    }
+    /**
+     *
+     * Referenced parent table & key
+     *
+     * @param table - parent table
+     * @param pKey - parant table key field
+     */
+    references(table, pKey) {
+        this.Table = table;
+        this.PrimaryKey = pKey;
+        return this;
+    }
+    /**
+     *
+     * On delete action
+     *
+     * @param action - action to take on delete
+     */
+    onDelete(action) {
+        this.OnDeleteAction = action;
+        return this;
+    }
+    /**
+     *
+     * On update action
+     *
+     * @param action - action to take on update
+     */
+    onUpdate(action) {
+        this.OnUpdateAction = action;
+        return this;
+    }
+    /**
+     * Shorhand for on update and on delete cascade settings
+     */
+    cascade() {
+        this.OnUpdateAction = interfaces_1.ReferentialAction.Cascade;
+        this.OnDeleteAction = interfaces_1.ReferentialAction.Cascade;
+        return this;
+    }
+};
+ForeignKeyBuilder = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [])
+], ForeignKeyBuilder);
+exports.ForeignKeyBuilder = ForeignKeyBuilder;
+let ColumnQueryBuilder = class ColumnQueryBuilder {
+    constructor(name, type, ...args) {
+        this.Name = name;
+        this.Type = type;
+        this.Charset = '';
+        this.Args = [];
+        this.AutoIncrement = false;
+        this.NotNull = false;
+        this.Default = '';
+        this.Collation = '';
+        this.Comment = '';
+        this.Unique = false;
+        this.Unsigned = false;
+        this.Args.push(...args);
+    }
+    notNull() {
+        this.NotNull = true;
+        return this;
+    }
+    unique() {
+        this.Unique = true;
+        return this;
+    }
+    unsigned() {
+        this.Unsigned = true;
+        return this;
+    }
+    autoIncrement() {
+        this.AutoIncrement = true;
+        return this;
+    }
+    default(val) {
+        this.Default = val;
+        return this;
+    }
+    primaryKey() {
+        this.PrimaryKey = true;
+        return this;
+    }
+    comment(comment) {
+        this.Comment = comment;
+        return this;
+    }
+    charset(charset) {
+        this.Charset = charset;
+        return this;
+    }
+    collation(collation) {
+        this.Collation = collation;
+        return this;
+    }
+};
+ColumnQueryBuilder = __decorate([
+    (0, di_1.NewInstance)(),
+    __metadata("design:paramtypes", [String, String, Object])
+], ColumnQueryBuilder);
+exports.ColumnQueryBuilder = ColumnQueryBuilder;
+class TableQueryBuilder extends QueryBuilder {
+    constructor(container, driver, name) {
+        super(container, driver, null);
+        this._charset = '';
+        this._comment = '';
+        this._columns = [];
+        this._foreignKeys = [];
+        this.setTable(name);
+        this._queryContext = interfaces_1.QueryContext.Schema;
+    }
+    get Columns() {
+        return this._columns;
+    }
+    get ForeignKeys() {
+        return this._foreignKeys;
+    }
+    increments(name) {
+        return this.int(name).autoIncrement().notNull().primaryKey();
+    }
+    comment(comment) {
+        this._comment = comment;
+    }
+    charset(charset) {
+        this._charset = charset;
+    }
+    foreignKey(foreignKey) {
+        const builder = new ForeignKeyBuilder();
+        builder.foreignKey(foreignKey);
+        this._foreignKeys.push(builder);
+        return builder;
+    }
+    toDB() {
+        return this._container.resolve(interfaces_1.TableQueryCompiler, [this]).compile();
+    }
+}
+exports.TableQueryBuilder = TableQueryBuilder;
+let SchemaQueryBuilder = class SchemaQueryBuilder {
+    constructor(container, driver) {
+        this.container = container;
+        this.driver = driver;
+    }
+    createTable(name, callback) {
+        const builder = new TableQueryBuilder(this.container, this.driver, name);
+        callback.call(this, builder);
+        return builder;
+    }
+};
+SchemaQueryBuilder = __decorate([
+    (0, di_1.NewInstance)(),
+    (0, di_1.Inject)(di_1.Container),
+    __metadata("design:paramtypes", [di_1.Container, driver_1.OrmDriver])
+], SchemaQueryBuilder);
+exports.SchemaQueryBuilder = SchemaQueryBuilder;
+Object.values(enums_1.ColumnType).forEach((type) => {
+    TableQueryBuilder.prototype[type] = function (name, ...args) {
+        const _builder = new ColumnQueryBuilder(name, type, ...args);
+        this._columns.push(_builder);
+        return _builder;
+    };
+});
+//# sourceMappingURL=builders.js.map