database-builder
Version:
Library to assist in creating and maintaining SQL commands.
295 lines (294 loc) • 13.5 kB
JavaScript
"use strict";
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProjectionBuilder = void 0;
var projections_utils_1 = require("../core/projections-utils");
var utils_1 = require("../core/utils");
var column_ref_1 = require("../core/column-ref");
var plan_ref_1 = require("../core/plan-ref");
var projection_compiled_1 = require("./projection-compiled");
var projection_1 = require("./enums/projection");
var projection_case_1 = require("./projection-case");
var projections_helper_1 = require("../core/projections-helper");
var errors_1 = require("../core/errors");
var projection_model_1 = require("./projection-model");
var projection_compile_1 = require("./projection-compile");
var mapper_utils_1 = require("../mapper/mapper-utils");
var ProjectionBuilder = /** @class */ (function () {
function ProjectionBuilder(_typeT, _aliasTable, _addAliasTableToAlias, addAliasDefault, _getMapper) {
if (_addAliasTableToAlias === void 0) { _addAliasTableToAlias = false; }
var _this = this;
this._typeT = _typeT;
this._aliasTable = _aliasTable;
this._addAliasTableToAlias = _addAliasTableToAlias;
this._getMapper = _getMapper;
this._projections = [];
this._projectionsUtils = new projections_utils_1.ProjectionsUtils(_aliasTable, _addAliasTableToAlias, addAliasDefault, function (projection) { return _this.applyProjection(projection); });
}
ProjectionBuilder.prototype.all = function () {
if (this._getMapper && this._typeT) {
this.allByMap(this._getMapper(this._typeT));
}
else {
this.wildcard();
}
};
ProjectionBuilder.prototype.wildcard = function () {
this.apply(projections_utils_1.ProjectionsUtils.WILDCARD);
};
ProjectionBuilder.prototype.allByMap = function (metadata) {
if (utils_1.Utils.isNull(metadata)) {
throw new errors_1.DatabaseBuilderError("Mapper not found for '".concat(mapper_utils_1.MapperUtils.resolveKey(this._typeT), "'"));
}
this.selectAllColumns(metadata.mapperTable);
};
ProjectionBuilder.prototype.proj = function () {
return new projections_helper_1.ProjectionsHelper(this._typeT, this._aliasTable, false);
};
ProjectionBuilder.prototype.ref = function (expression, alias) {
if (alias === void 0) { alias = this._aliasTable; }
return new column_ref_1.ColumnRef(utils_1.Utils.getColumn(expression), alias);
};
ProjectionBuilder.prototype.plan = function (value) {
return new plan_ref_1.PlanRef(value);
};
ProjectionBuilder.prototype.group = function (alias) {
var _a;
var projections = [];
for (var _i = 1; _i < arguments.length; _i++) {
projections[_i - 1] = arguments[_i];
}
var groupProjection = (_a = this.proj()).group.apply(_a, __spreadArray([alias], projections, false))._result();
var groupCompiled = projection_compile_1.ProjectionCompile.compile(groupProjection);
this.apply(groupCompiled.projection, [], "", groupCompiled.params);
return this;
};
/**
* @deprecated Use `add`
* @param column
* @param alias
*/
ProjectionBuilder.prototype.column = function (column, alias) {
this.apply(column, void 0, alias);
return this;
};
ProjectionBuilder.prototype.columns = function () {
var expressions = [];
for (var _i = 0; _i < arguments.length; _i++) {
expressions[_i] = arguments[_i];
}
for (var key in expressions) {
if (expressions.hasOwnProperty(key)) {
var expression = expressions[key];
this.add(expression);
}
}
return this;
};
ProjectionBuilder.prototype.add = function (
// expression: ExpressionOrColumn<TReturn, T> | QueryCompiled[] | SqlCompilable,
expression, alias) {
if (utils_1.Utils.isQueryCompilable(expression) || utils_1.Utils.isQueryCompiledArray(expression)) {
return this.subQuery(expression, alias);
}
this.buildProjectionWithExpression(void 0, expression, alias);
return this;
};
ProjectionBuilder.prototype.remove = function (expression) {
var column = this._projectionsUtils.create(utils_1.Utils.getColumn(expression)).projection;
var indexRemove = this._projections.findIndex(function (x) { return x.projection === column; });
if (indexRemove > -1) {
this._projections.splice(indexRemove, 1);
}
return this;
};
ProjectionBuilder.prototype.clean = function () {
this._projections = [];
return this;
};
ProjectionBuilder.prototype.sum = function (expression, alias) {
this.buildProjectionWithExpression(projection_1.Projection.Sum, expression, alias);
return this;
};
ProjectionBuilder.prototype.max = function (expression, alias) {
this.buildProjectionWithExpression(projection_1.Projection.Max, expression, alias);
return this;
};
ProjectionBuilder.prototype.min = function (expression, alias) {
this.buildProjectionWithExpression(projection_1.Projection.Min, expression, alias);
return this;
};
ProjectionBuilder.prototype.avg = function (expression, alias) {
this.buildProjectionWithExpression(projection_1.Projection.Avg, expression, alias);
return this;
};
/**
* @deprecated use `.avg().round(expression)`
*
* @param {ExpressionOrColumn<T>} expression
* @param {string} [alias]
* @returns {ProjectionBuilder<T>}
* @memberof ProjectionBuilder
*/
ProjectionBuilder.prototype.avgRound = function (expression, alias) {
this.apply(expression, [projection_1.Projection.Round, projection_1.Projection.Avg], alias);
return this;
};
ProjectionBuilder.prototype.round = function (expression, alias) {
this.buildProjectionWithExpression(projection_1.Projection.Round, expression, alias);
return this;
};
ProjectionBuilder.prototype.count = function (expression, alias) {
this.buildProjectionWithExpression(projection_1.Projection.Count, expression, alias);
return this;
};
/**
* @deprecated use `.count().distinct(expression)`
*
* @param {ExpressionOrColumn<T>} expression
* @param {string} [alias]
* @returns {ProjectionBuilder<T>}
* @memberof ProjectionBuilder
*/
ProjectionBuilder.prototype.countDistinct = function (expression, alias) {
this.apply(expression, [projection_1.Projection.Count, projection_1.Projection.Distinct], alias);
return this;
};
ProjectionBuilder.prototype.cast = function (expression, alias) {
this.buildProjectionWithExpression(projection_1.Projection.Cast, expression, alias);
return this;
};
ProjectionBuilder.prototype.distinct = function (expression, alias) {
this.buildProjectionWithExpression(projection_1.Projection.Distinct, expression, alias);
return this;
};
/**
* https://www.sqlite.org/lang_expr.html
* CASE {expression} {when} END
* @param caseCallback
* @param expression
* @param alias
*/
ProjectionBuilder.prototype.case = function (caseCallback, expression, alias) {
if (expression === void 0) { expression = void 0; }
var instanceCase = new projection_case_1.ProjectionCase(expression, alias);
caseCallback(instanceCase);
this.compileCase(instanceCase.compile());
return this;
};
ProjectionBuilder.prototype.coalesce = function (expression, alias) {
this.buildProjectionWithExpression(projection_1.Projection.Coalesce, expression, alias);
return this;
};
ProjectionBuilder.prototype.coalesceP = function (projectionCallback, defaultValue, alias) {
var instanceProjection = new ProjectionBuilder(this._typeT, this._aliasTable, void 0, false, this._getMapper);
projectionCallback(instanceProjection);
var projectionInner = projection_compile_1.ProjectionCompile.compile(instanceProjection.result());
this.buildProjectionWithExpression(projection_1.Projection.Coalesce, "".concat(projectionInner.projection, ", ").concat(defaultValue), alias, projectionInner.params);
return this;
};
/**
* @deprecated use `.proj()`
*
* @param {Projection} projection
* @param {ExpressionOrColumn<T>} expression
* @param {string} [alias=""]
* @param {any[]} [args=[]]
* @returns
* @memberof ProjectionBuilder
*/
ProjectionBuilder.prototype.projection = function (projection, expression, alias, args) {
if (alias === void 0) { alias = ""; }
if (args === void 0) { args = []; }
return this.createProjection(projection, this.addAliasTable(utils_1.Utils.getColumn(expression)), alias, args);
};
// TODO: fazer coalesce para subQuery
ProjectionBuilder.prototype.coalesceBuilder = function (expression, defaultValue) {
return this.builderProjection(projection_1.Projection.Coalesce, this.addAliasTable(utils_1.Utils.getColumn(expression)), [defaultValue]);
};
ProjectionBuilder.prototype.subQuery = function (subQuery, alias) {
var _this = this;
if (alias === void 0) { alias = ""; }
if (utils_1.Utils.isQueryCompilable(subQuery)) {
return this.subQuery(subQuery.compile(), alias);
}
subQuery
.forEach(function (compiled) {
_this.apply(compiled.query, [projection_1.Projection.BetweenParenthesis], alias, compiled.params);
});
return this;
};
ProjectionBuilder.prototype.result = function () {
return this._projections;
};
ProjectionBuilder.prototype.selectAllColumns = function (mapper) {
var columns = mapper.columns.filter(function (x) { return utils_1.Utils.isNull(x.tableReference); });
for (var key in columns) {
if (columns.hasOwnProperty(key)) {
var column = columns[key];
this.add(column.column);
}
}
};
ProjectionBuilder.prototype.compileCase = function (compiled) {
if (compiled.builder.length) {
this.applyProjection(new projection_model_1.ProjectionModel(compiled.builder, compiled.params));
}
};
ProjectionBuilder.prototype.buildProjectionWithExpression = function (projection, expression, alias, args) {
if (args === void 0) { args = []; }
this.apply(expression, projection ? [projection] : void 0, alias, args);
};
ProjectionBuilder.prototype.apply = function (expression, projections, alias, args) {
if (projections === void 0) { projections = []; }
this._projectionsUtils.apply(expression, projections, alias, args);
};
ProjectionBuilder.prototype.applyProjection = function (projection) {
this._projections.push(projection);
};
ProjectionBuilder.prototype.addAliasTable = function (column) {
if (utils_1.Utils.isNameColumn(column)) {
return "".concat(this._aliasTable, ".").concat(column);
}
return column;
};
ProjectionBuilder.prototype.builderProjection = function (projection, column, args) {
return "".concat(projection, "(").concat(column).concat(this.buildArgs(args), ")");
};
ProjectionBuilder.prototype.buildArgs = function (args) {
if (args === void 0) { args = []; }
return args.length ? ", " + args.join("") : "";
};
ProjectionBuilder.prototype.defaultAliasAs = function (column) {
if (column === projections_utils_1.ProjectionsUtils.WILDCARD) {
return "";
}
return this._addAliasTableToAlias
? "".concat(this._aliasTable, "_").concat(column)
: column;
};
ProjectionBuilder.prototype.createProjection = function (projection, column, alias, args) {
if (alias === void 0) { alias = this.defaultAliasAs(column); }
if (!utils_1.Utils.isNull(projection)) {
return this.buildColumn(this.builderProjection(projection, column, args), alias);
}
return this.buildColumn(column, alias);
};
ProjectionBuilder.prototype.buildColumn = function (column, alias) {
if (alias === void 0) { alias = this.defaultAliasAs(column); }
if (alias && alias.length) {
return new projection_compiled_1.ProjectionCompiled("".concat(column, " AS ").concat(alias), []);
}
return new projection_compiled_1.ProjectionCompiled(column, []);
};
return ProjectionBuilder;
}());
exports.ProjectionBuilder = ProjectionBuilder;